pcs-0.9.155/000077500000000000000000000000001301012375000124505ustar00rootroot00000000000000pcs-0.9.155/.gitignore000066400000000000000000000002331301012375000144360ustar00rootroot00000000000000*.pyc *.swp /MANIFEST /dist/ /pcs/bash_completion.d.pcs /pcsd/pcs_settings.conf /pcsd/pcs_settings.conf.* /pcsd/pcs_users.conf /pcsd/.bundle /pcsd/vendor pcs-0.9.155/CHANGELOG.md000066400000000000000000000032651301012375000142670ustar00rootroot00000000000000# Change Log ## [0.9.155] - 2016-11-03 ### Added - Show daemon status in `pcs status` on non-systemd machines - SBD support for cman clusters ([rhbz#1380352]) - Alerts management in pcsd ([rhbz#1376480]) ### Changed - Get all information about resource and stonith agents from pacemaker. Pcs now supports the same set of agents as pacemaker does. ([rhbz#1262001], [ghissue#81]) - `pcs resource create` now exits with an error if more than one resource agent matches the specified short agent name instead of randomly selecting one of the agents - Allow to remove multiple alerts and alert recipients at once ### Fixed - When stopping a cluster with some of the nodes unreachable, stop the cluster completely on all reachable nodes ([rhbz#1380372]) - Fixed pcsd crash when rpam rubygem is installed ([ghissue#109]) - Fixed occasional crashes / failures when using locale other than en_US.UTF8 ([rhbz#1387106]) - Fixed starting and stopping cluster services on systemd machines without the `service` executable ([ghissue#115]) [ghissue#81]: https://github.com/ClusterLabs/pcs/issues/81 [ghissue#109]: https://github.com/ClusterLabs/pcs/issues/109 [ghissue#115]: https://github.com/ClusterLabs/pcs/issues/115 [rhbz#1262001]: https://bugzilla.redhat.com/show_bug.cgi?id=1262001 [rhbz#1376480]: https://bugzilla.redhat.com/show_bug.cgi?id=1376480 [rhbz#1380352]: https://bugzilla.redhat.com/show_bug.cgi?id=1380352 [rhbz#1380372]: https://bugzilla.redhat.com/show_bug.cgi?id=1380372 [rhbz#1387106]: https://bugzilla.redhat.com/show_bug.cgi?id=1387106 ## [0.9.154] - 2016-09-21 - There is no change log for this and previous releases. We are sorry. - Take a look at git history if you are interested. pcs-0.9.155/COPYING000066400000000000000000000432541301012375000135130ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) 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 this service 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 make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. 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. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), 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 distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the 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 a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE 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. 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 convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 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, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision 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, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This 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. pcs-0.9.155/MANIFEST.in000066400000000000000000000003341301012375000142060ustar00rootroot00000000000000include Makefile include COPYING include pcs/pcs.8 include pcs/bash_completion.sh include pcsd/.bundle/config graft pcsd graft pcsd/vendor/cache prune pcsd/vendor/bundle prune pcsd/test recursive-exclude pcsd .gitignore pcs-0.9.155/Makefile000066400000000000000000000122301301012375000141060ustar00rootroot00000000000000# Compatibility with GNU/Linux [i.e. Debian] based distros UNAME_OS_GNU := $(shell if uname -o | grep -q "GNU/Linux" ; then echo true; else echo false; fi) DISTRO_DEBIAN := $(shell if [ -e /etc/debian_version ] ; then echo true; else echo false; fi) IS_DEBIAN=false DISTRO_DEBIAN_VER_8=false ifndef PYTHON PYTHON=python endif ifeq ($(UNAME_OS_GNU),true) ifeq ($(DISTRO_DEBIAN),true) IS_DEBIAN=true DISTRO_DEBIAN_VER_8 := $(shell if grep -q -i "^8\|jessie" /etc/debian_version ; then echo true; else echo false; fi) # dpkg-architecture is in the optional dpkg-dev package, unfortunately. #DEB_HOST_MULTIARCH := $(shell dpkg-architecture -qDEB_HOST_MULTIARCH) # TODO: Use lsb_architecture to get the multiarch tuple if/when it becomes available in distributions. DEB_HOST_MULTIARCH := $(shell dpkg -L libc6 | sed -nr 's|^/etc/ld\.so\.conf\.d/(.*)\.conf$$|\1|p') endif endif ifndef PYTHON_SITELIB PYTHON_SITELIB=$(shell $(PYTHON) -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())") endif ifeq ($(PYTHON_SITELIB), /usr/lib/python2.6/dist-packages) EXTRA_SETUP_OPTS="--install-layout=deb" endif ifeq ($(PYTHON_SITELIB), /usr/lib/python2.7/dist-packages) EXTRA_SETUP_OPTS="--install-layout=deb" endif # Check for systemd presence, add compatibility with Debian based distros IS_SYSTEMCTL=false ifeq ($(IS_DEBIAN),true) IS_SYSTEMCTL = $(shell if [ -d /var/run/systemd/system ] ; then echo true ; else echo false; fi) ifeq ($(IS_SYSTEMCTL),false) ifeq ($(SYSTEMCTL_OVERRIDE),true) IS_SYSTEMCTL=true endif endif else ifeq ("$(wildcard /usr/bin/systemctl)","/usr/bin/systemctl") IS_SYSTEMCTL=true else ifeq ("$(wildcard /bin/systemctl)","/usr/bin/systemctl") IS_SYSTEMCTL=true endif endif endif # Check for an override for building gems ifndef BUILD_GEMS BUILD_GEMS=true endif MANDIR=/usr/share/man ifndef PREFIX PREFIX=$(shell prefix=`$(PYTHON) -c "import sys; print(sys.prefix)"` || prefix="/usr"; echo $$prefix) endif ifndef systemddir systemddir=/usr/lib/systemd endif ifndef initdir initdir=/etc/init.d endif ifndef install_settings ifeq ($(IS_DEBIAN),true) install_settings=true else install_settings=false endif endif ifndef BASH_COMPLETION_DIR BASH_COMPLETION_DIR=${DESTDIR}/etc/bash_completion.d endif install: $(PYTHON) setup.py install --root=$(or ${DESTDIR}, /) ${EXTRA_SETUP_OPTS} mkdir -p ${DESTDIR}${PREFIX}/sbin/ mv ${DESTDIR}${PREFIX}/bin/pcs ${DESTDIR}${PREFIX}/sbin/pcs install -D -m644 pcs/bash_completion.sh ${BASH_COMPLETION_DIR}/pcs install -m644 -D pcs/pcs.8 ${DESTDIR}/${MANDIR}/man8/pcs.8 ifeq ($(IS_DEBIAN),true) ifeq ($(install_settings),true) rm -f ${DESTDIR}${PYTHON_SITELIB}/pcs/settings.py tmp_settings=`mktemp`; \ sed s/DEB_HOST_MULTIARCH/${DEB_HOST_MULTIARCH}/g pcs/settings.py.debian > $$tmp_settings; \ install -m644 $$tmp_settings ${DESTDIR}${PYTHON_SITELIB}/pcs/settings.py; \ rm -f $$tmp_settings $(PYTHON) -m compileall -fl ${DESTDIR}${PYTHON_SITELIB}/pcs/settings.py endif endif install_pcsd: ifeq ($(BUILD_GEMS),true) make -C pcsd build_gems endif mkdir -p ${DESTDIR}/var/log/pcsd ifeq ($(IS_DEBIAN),true) mkdir -p ${DESTDIR}/usr/share/ cp -r pcsd ${DESTDIR}/usr/share/ install -m 644 -D pcsd/pcsd.conf ${DESTDIR}/etc/default/pcsd install -d ${DESTDIR}/etc/pam.d install pcsd/pcsd.pam.debian ${DESTDIR}/etc/pam.d/pcsd ifeq ($(install_settings),true) rm -f ${DESTDIR}/usr/share/pcsd/settings.rb tmp_settings_pcsd=`mktemp`; \ sed s/DEB_HOST_MULTIARCH/${DEB_HOST_MULTIARCH}/g pcsd/settings.rb.debian > $$tmp_settings_pcsd; \ install -m644 $$tmp_settings_pcsd ${DESTDIR}/usr/share/pcsd/settings.rb; \ rm -f $$tmp_settings_pcsd endif ifeq ($(IS_SYSTEMCTL),true) install -d ${DESTDIR}/${systemddir}/system/ install -m 644 pcsd/pcsd.service.debian ${DESTDIR}/${systemddir}/system/pcsd.service else install -m 755 -D pcsd/pcsd.debian ${DESTDIR}/${initdir}/pcsd endif else mkdir -p ${DESTDIR}${PREFIX}/lib/ cp -r pcsd ${DESTDIR}${PREFIX}/lib/ install -m 644 -D pcsd/pcsd.conf ${DESTDIR}/etc/sysconfig/pcsd install -d ${DESTDIR}/etc/pam.d install pcsd/pcsd.pam ${DESTDIR}/etc/pam.d/pcsd ifeq ($(IS_SYSTEMCTL),true) install -d ${DESTDIR}/${systemddir}/system/ install -m 644 pcsd/pcsd.service ${DESTDIR}/${systemddir}/system/ # ${DESTDIR}${PREFIX}/lib/pcsd/pcsd holds the selinux context install -m 755 pcsd/pcsd.service-runner ${DESTDIR}${PREFIX}/lib/pcsd/pcsd rm ${DESTDIR}${PREFIX}/lib/pcsd/pcsd.service-runner else install -m 755 -D pcsd/pcsd ${DESTDIR}/${initdir}/pcsd endif endif install -m 700 -d ${DESTDIR}/var/lib/pcsd install -m 644 -D pcsd/pcsd.logrotate ${DESTDIR}/etc/logrotate.d/pcsd uninstall: rm -f ${DESTDIR}${PREFIX}/sbin/pcs rm -rf ${DESTDIR}${PYTHON_SITELIB}/pcs ifeq ($(IS_DEBIAN),true) rm -rf ${DESTDIR}/usr/share/pcsd else rm -rf ${DESTDIR}${PREFIX}/lib/pcsd endif ifeq ($(IS_SYSTEMCTL),true) rm -f ${DESTDIR}/${systemddir}/system/pcsd.service else rm -f ${DESTDIR}/${initdir}/pcsd endif rm -f ${DESTDIR}/etc/pam.d/pcsd rm -rf ${DESTDIR}/var/lib/pcsd tarball: $(PYTHON) setup.py sdist --formats=tar $(PYTHON) maketarballs.py newversion: $(PYTHON) newversion.py pcs-0.9.155/README000066400000000000000000000030411301012375000133260ustar00rootroot00000000000000PCS - Pacemaker/Corosync configuration system Quick start To install pcs run the following in terminal # tar -xzvf pcs-0.9.143.tar.gz # cd pcs-0.9.143 # make install This will install pcs into /usr/sbin/pcs To create a cluster run the following commands on all nodes (replacing node1, node2, node3 with a list of nodes in the cluster). # pcs cluster setup --local --name cluster_name node1 node2 node3 Then run the following command on all nodes: # pcs cluster start After a few moments the cluster should startup and you can get the status of the cluster # pcs status After this you can add resources and stonith agents: # pcs resource help and # pcs stonith help You can also install pcsd which operates as a GUI and remote server for pcs. pcsd may also be necessary in order to follow the guides on the clusterlabs.org website. To install pcsd run the following commands from the root of your pcs directory. (You must have the ruby bundler gem installed, rubygem-bundler in Fedora, and development packages installed) # cd pcsd ; make get_gems ; cd .. # make install_pcsd If you are using GNU/Linux its now time to: # systemctl daemon-reload Currently this is built into Fedora (other distributions to follow). You can see the current Fedora .spec in the fedora package git repositories here: http://pkgs.fedoraproject.org/cgit/pcs.git/ Current Fedora 23 .spec: http://pkgs.fedoraproject.org/cgit/pcs.git/tree/pcs.spec?h=f23 If you have an questions or concerns please feel free to email cfeist@redhat.com or open a github issue on the pcs project. pcs-0.9.155/README.md000066400000000000000000000040071301012375000137300ustar00rootroot00000000000000## PCS - Pacemaker/Corosync configuration system ### Quick Start *** - **PCS Installation from Source** Run the following in terminal: ```shell # tar -xzvf pcs-0.9.143.tar.gz # cd pcs-0.9.143 # make install ``` This will install pcs into `/usr/sbin/pcs`.
- **Create and Start a Basic Cluster** To create a cluster run the following commands on all nodes (replacing node1, node2, node3 with a list of nodes in the cluster). ```shell # pcs cluster setup --local --name cluster_name node1 node2 node3 ``` Then run the following command on all nodes: ```shell # pcs cluster start ```
- **Check the Cluster Status** After a few moments the cluster should startup and you can get the status of the cluster ```shell # pcs status ```
- **Add Cluster Resources** After this you can add resources and stonith agents: ```shell # pcs resource help ``` and ```shell # pcs stonith help ```
- **PCSD Installation from Source** You can also install pcsd which operates as a GUI and remote server for pcs. pcsd may also be necessary in order to follow the guides on the clusterlabs.org website. To install pcsd run the following commands from the root of your pcs directory. (You must have the ruby bundler gem installed, rubygem-bundler in Fedora, and development packages installed) ```shell # cd pcsd ; make get_gems ; cd .. # make install_pcsd ``` If you are using GNU/Linux its now time to: ```shell # systemctl daemon-reload ```
### Packages *** Currently this is built into Fedora (other distributions to follow). You can see the current Fedora .spec in the fedora package git repositories here: http://pkgs.fedoraproject.org/cgit/pcs.git/ Current Fedora 23 .spec: http://pkgs.fedoraproject.org/cgit/pcs.git/tree/pcs.spec?h=f23
### Inquiries *** If you have any questions or concerns please feel free to email cfeist@redhat.com or open a github issue on the pcs project. pcs-0.9.155/maketarballs.py000066400000000000000000000011621301012375000154640ustar00rootroot00000000000000#!/usr/bin/python from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals import sys import os sys.path.insert( 0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "pcs") ) import settings pcs_version = settings.pcs_version print(os.system("cp dist/pcs-"+pcs_version+".tar dist/pcs-withgems-"+pcs_version+".tar")) print(os.system("tar --delete -f dist/pcs-"+pcs_version+".tar '*/pcsd/vendor'")) print(os.system("gzip dist/pcs-"+pcs_version+".tar")) print(os.system("gzip dist/pcs-withgems-"+pcs_version+".tar")) pcs-0.9.155/newversion.py000066400000000000000000000027431301012375000152270ustar00rootroot00000000000000#!/usr/bin/python from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals import sys import os import locale import datetime sys.path.insert( 0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "pcs") ) import settings locale.setlocale(locale.LC_ALL, ("en_US", "UTF-8")) # Get the current version, increment by 1, verify changes, git commit & tag pcs_version_split = settings.pcs_version.split('.') pcs_version_split[2] = str(int(pcs_version_split[2]) + 1) new_version = ".".join(pcs_version_split) print(os.system("sed -i 's/"+settings.pcs_version+"/"+new_version+"/' setup.py")) print(os.system("sed -i 's/"+settings.pcs_version+"/"+new_version+"/' pcs/settings_default.py")) print(os.system("sed -i 's/"+settings.pcs_version+"/"+new_version+"/' pcsd/bootstrap.rb")) print(os.system("sed -i 's/\#\# \[Unreleased\]/\#\# ["+new_version+"] - "+datetime.date.today().strftime('%Y-%m-%d')+"/' CHANGELOG.md")) manpage_head = '.TH PCS "8" "{date}" "pcs {version}" "System Administration Utilities"'.format( date=datetime.date.today().strftime('%B %Y'), version=new_version ) print(os.system("sed -i '1c " + manpage_head + "' pcs/pcs.8")) print(os.system("git diff")) print("Look good? (y/n)") choice = sys.stdin.read(1) if choice != "y": print("Ok, exiting") sys.exit(0) print(os.system("git commit -a -m 'Bumped to "+new_version+"'")) print(os.system("git tag "+new_version)) pcs-0.9.155/pcs/000077500000000000000000000000001301012375000132355ustar00rootroot00000000000000pcs-0.9.155/pcs/COPYING000066400000000000000000000432541301012375000143000ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) 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 this service 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 make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. 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. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), 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 distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the 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 a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE 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. 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 convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 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, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision 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, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This 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. pcs-0.9.155/pcs/__init__.py000066400000000000000000000000001301012375000153340ustar00rootroot00000000000000pcs-0.9.155/pcs/acl.py000066400000000000000000000230111301012375000143430ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import sys from pcs import ( prop, usage, utils, ) from pcs.lib.pacemaker_values import is_true from pcs.cli.common.console_report import indent from pcs.cli.common.errors import CmdLineInputError from pcs.lib.errors import LibraryError def acl_cmd(lib, argv, modifiers): if len(argv) < 1: sub_cmd, argv_next = "show", [] else: sub_cmd, argv_next = argv[0], argv[1:] try: if sub_cmd == "help": usage.acl(argv_next) elif sub_cmd == "show": show_acl_config(lib, argv_next, modifiers) elif sub_cmd == "enable": acl_enable(argv_next) elif sub_cmd == "disable": acl_disable(argv_next) elif sub_cmd == "role": acl_role(lib, argv_next, modifiers) elif sub_cmd in ["target", "user"]: acl_user(lib, argv_next, modifiers) elif sub_cmd == "group": acl_group(lib, argv_next, modifiers) elif sub_cmd == "permission": acl_permission(lib, argv_next, modifiers) else: raise CmdLineInputError() except LibraryError as e: utils.process_library_reports(e.args) except CmdLineInputError as e: utils.exit_on_cmdline_input_errror(e, "acl", sub_cmd) def _print_list_of_objects(obj_list, transformation_fn): out = [] for obj in obj_list: out += transformation_fn(obj) if out: print("\n".join(out)) def show_acl_config(lib, argv, modifiers): # TODO move to lib once lib supports cluster properties # enabled/disabled should be part of the structure returned # by lib.acl.get_config properties = utils.get_set_properties(defaults=prop.get_default_properties()) acl_enabled = properties.get("enable-acl", "").lower() if is_true(acl_enabled): print("ACLs are enabled") else: print("ACLs are disabled, run 'pcs acl enable' to enable") print() data = lib.acl.get_config() _print_list_of_objects(data.get("target_list", []), target_to_str) _print_list_of_objects(data.get("group_list", []), group_to_str) _print_list_of_objects(data.get("role_list", []), role_to_str) def acl_enable(argv): # TODO move to lib once lib supports cluster properties prop.set_property(["enable-acl=true"]) def acl_disable(argv): # TODO move to lib once lib supports cluster properties prop.set_property(["enable-acl=false"]) def acl_role(lib, argv, modifiers): if len(argv) < 1: raise CmdLineInputError() sub_cmd, argv_next = argv[0], argv[1:] try: if sub_cmd == "create": role_create(lib, argv_next, modifiers) elif sub_cmd == "delete": role_delete(lib, argv_next, modifiers) elif sub_cmd == "assign": role_assign(lib, argv_next, modifiers) elif sub_cmd == "unassign": role_unassign(lib, argv_next, modifiers) else: usage.show("acl", ["role"]) sys.exit(1) except CmdLineInputError as e: utils.exit_on_cmdline_input_errror(e, "acl", "role {0}".format(sub_cmd)) def acl_user(lib, argv, modifiers): if len(argv) < 1: raise CmdLineInputError() sub_cmd, argv_next = argv[0], argv[1:] try: if sub_cmd == "create": user_create(lib, argv_next, modifiers) elif sub_cmd == "delete": user_delete(lib, argv_next, modifiers) else: usage.show("acl", ["user"]) sys.exit(1) except CmdLineInputError as e: utils.exit_on_cmdline_input_errror(e, "acl", "user {0}".format(sub_cmd)) def user_create(lib, argv, dummy_modifiers): if len(argv) < 1: raise CmdLineInputError() user_name, role_list = argv[0], argv[1:] lib.acl.create_target(user_name, role_list) def user_delete(lib, argv, dummy_modifiers): if len(argv) != 1: raise CmdLineInputError() lib.acl.remove_target(argv[0]) def acl_group(lib, argv, modifiers): if len(argv) < 1: raise CmdLineInputError() sub_cmd, argv_next = argv[0], argv[1:] try: if sub_cmd == "create": group_create(lib, argv_next, modifiers) elif sub_cmd == "delete": group_delete(lib, argv_next, modifiers) else: usage.show("acl", ["group"]) sys.exit(1) except CmdLineInputError as e: utils.exit_on_cmdline_input_errror( e, "acl", "group {0}".format(sub_cmd) ) def group_create(lib, argv, dummy_modifiers): if len(argv) < 1: raise CmdLineInputError() group_name, role_list = argv[0], argv[1:] lib.acl.create_group(group_name, role_list) def group_delete(lib, argv, dummy_modifiers): if len(argv) != 1: raise CmdLineInputError() lib.acl.remove_group(argv[0]) def acl_permission(lib, argv, modifiers): if len(argv) < 1: raise CmdLineInputError() sub_cmd, argv_next = argv[0], argv[1:] try: if sub_cmd == "add": permission_add(lib, argv_next, modifiers) elif sub_cmd == "delete": run_permission_delete(lib, argv_next, modifiers) else: usage.show("acl", ["permission"]) sys.exit(1) except CmdLineInputError as e: utils.exit_on_cmdline_input_errror( e, "acl", "permission {0}".format(sub_cmd) ) def argv_to_permission_info_list(argv): if len(argv) % 3 != 0: raise CmdLineInputError() #wrapping by list, #because in python3 zip() returns an iterator instead of a list #and the loop below makes iteration over it permission_info_list = list(zip( [permission.lower() for permission in argv[::3]], [scope_type.lower() for scope_type in argv[1::3]], argv[2::3] )) for permission, scope_type, dummy_scope in permission_info_list: if( permission not in ['read', 'write', 'deny'] or scope_type not in ['xpath', 'id'] ): raise CmdLineInputError() return permission_info_list def role_create(lib, argv, modifiers): if len(argv) < 1: raise CmdLineInputError() role_id = argv.pop(0) description = "" desc_key = 'description=' if argv and argv[0].startswith(desc_key) and len(argv[0]) > len(desc_key): description = argv.pop(0)[len(desc_key):] permission_info_list = argv_to_permission_info_list(argv) lib.acl.create_role(role_id, permission_info_list, description) def role_delete(lib, argv, modifiers): if len(argv) != 1: raise CmdLineInputError() lib.acl.remove_role(argv[0], autodelete_users_groups=True) def _role_assign_unassign(argv, keyword, not_specific_fn, user_fn, group_fn): argv_len = len(argv) if argv_len < 2: raise CmdLineInputError() if argv_len == 2: not_specific_fn(*argv) elif argv_len == 3: role_id, something, ug_id = argv if something == keyword: not_specific_fn(role_id, ug_id) elif something == "user": user_fn(role_id, ug_id) elif something == "group": group_fn(role_id, ug_id) else: raise CmdLineInputError() elif argv_len == 4 and argv[1] == keyword and argv[2] in ["group", "user"]: role_id, _, user_group, ug_id = argv if user_group == "user": user_fn(role_id, ug_id) else: group_fn(role_id, ug_id) else: raise CmdLineInputError() def role_assign(lib, argv, dummy_modifiers): _role_assign_unassign( argv, "to", lib.acl.assign_role_not_specific, lib.acl.assign_role_to_target, lib.acl.assign_role_to_group ) def role_unassign(lib, argv, modifiers): _role_assign_unassign( argv, "from", lambda role_id, ug_id: lib.acl.unassign_role_not_specific( role_id, ug_id, modifiers.get("autodelete", False) ), lambda role_id, ug_id: lib.acl.unassign_role_from_target( role_id, ug_id, modifiers.get("autodelete", False) ), lambda role_id, ug_id: lib.acl.unassign_role_from_group( role_id, ug_id, modifiers.get("autodelete", False) ) ) def permission_add(lib, argv, dummy_modifiers): if len(argv) < 4: raise CmdLineInputError() role_id, argv_next = argv[0], argv[1:] lib.acl.add_permission(role_id, argv_to_permission_info_list(argv_next)) def run_permission_delete(lib, argv, dummy_modifiers): if len(argv) != 1: raise CmdLineInputError() lib.acl.remove_permission(argv[0]) def _target_group_to_str(type_name, obj): return ["{0}: {1}".format(type_name.title(), obj.get("id"))] + indent( [" ".join(["Roles:"] + obj.get("role_list", []))] ) def target_to_str(target): return _target_group_to_str("user", target) def group_to_str(group): return _target_group_to_str("group", group) def role_to_str(role): out = [] if role.get("description"): out.append("Description: {0}".format(role.get("description"))) out += map(_permission_to_str, role.get("permission_list", [])) return ["Role: {0}".format(role.get("id"))] + indent(out) def _permission_to_str(permission): out = ["Permission:", permission.get("kind")] if permission.get("xpath") is not None: out += ["xpath", permission.get("xpath")] elif permission.get("reference") is not None: out += ["id", permission.get("reference")] out.append("({0})".format(permission.get("id"))) return " ".join(out) pcs-0.9.155/pcs/alert.py000066400000000000000000000152371301012375000147260ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import sys import json from functools import partial from pcs import ( usage, utils, ) from pcs.cli.common.errors import CmdLineInputError from pcs.cli.common.parse_args import prepare_options, group_by_keywords from pcs.cli.common.console_report import indent from pcs.lib.errors import LibraryError parse_cmd_sections = partial(group_by_keywords, implicit_first_keyword="main") def alert_cmd(*args): argv = args[1] if not argv: sub_cmd = "config" else: sub_cmd = argv.pop(0) try: if sub_cmd == "help": usage.alert(argv) elif sub_cmd == "create": alert_add(*args) elif sub_cmd == "update": alert_update(*args) elif sub_cmd == "remove": alert_remove(*args) elif sub_cmd == "config" or sub_cmd == "show": print_alert_config(*args) elif sub_cmd == "recipient": recipient_cmd(*args) elif sub_cmd == "get_all_alerts": print_alerts_in_json(*args) else: raise CmdLineInputError() except LibraryError as e: utils.process_library_reports(e.args) except CmdLineInputError as e: utils.exit_on_cmdline_input_errror(e, "alert", sub_cmd) def recipient_cmd(*args): argv = args[1] if not argv: usage.alert(["recipient"]) sys.exit(1) sub_cmd = argv.pop(0) try: if sub_cmd == "help": usage.alert(["recipient"]) elif sub_cmd == "add": recipient_add(*args) elif sub_cmd == "update": recipient_update(*args) elif sub_cmd == "remove": recipient_remove(*args) else: raise CmdLineInputError() except CmdLineInputError as e: utils.exit_on_cmdline_input_errror( e, "alert", "recipient {0}".format(sub_cmd) ) def ensure_only_allowed_options(parameter_dict, allowed_list): for arg, value in parameter_dict.items(): if arg not in allowed_list: raise CmdLineInputError( "Unexpected parameter '{0}={1}'".format(arg, value) ) def alert_add(lib, argv, modifiers): if not argv: raise CmdLineInputError() sections = parse_cmd_sections(argv, set(["options", "meta"])) main_args = prepare_options(sections["main"]) ensure_only_allowed_options(main_args, ["id", "description", "path"]) lib.alert.create_alert( main_args.get("id", None), main_args.get("path", None), prepare_options(sections["options"]), prepare_options(sections["meta"]), main_args.get("description", None) ) def alert_update(lib, argv, modifiers): if not argv: raise CmdLineInputError() alert_id = argv[0] sections = parse_cmd_sections(argv[1:], set(["options", "meta"])) main_args = prepare_options(sections["main"]) ensure_only_allowed_options(main_args, ["description", "path"]) lib.alert.update_alert( alert_id, main_args.get("path", None), prepare_options(sections["options"]), prepare_options(sections["meta"]), main_args.get("description", None) ) def alert_remove(lib, argv, modifiers): if len(argv) < 1: raise CmdLineInputError() lib.alert.remove_alert(argv) def recipient_add(lib, argv, modifiers): if len(argv) < 2: raise CmdLineInputError() alert_id = argv[0] sections = parse_cmd_sections(argv[1:], set(["options", "meta"])) main_args = prepare_options(sections["main"]) ensure_only_allowed_options(main_args, ["description", "id", "value"]) lib.alert.add_recipient( alert_id, main_args.get("value", None), prepare_options(sections["options"]), prepare_options(sections["meta"]), recipient_id=main_args.get("id", None), description=main_args.get("description", None), allow_same_value=modifiers["force"] ) def recipient_update(lib, argv, modifiers): if len(argv) < 1: raise CmdLineInputError() recipient_id = argv[0] sections = parse_cmd_sections(argv[1:], set(["options", "meta"])) main_args = prepare_options(sections["main"]) ensure_only_allowed_options(main_args, ["description", "value"]) lib.alert.update_recipient( recipient_id, prepare_options(sections["options"]), prepare_options(sections["meta"]), recipient_value=main_args.get("value", None), description=main_args.get("description", None), allow_same_value=modifiers["force"] ) def recipient_remove(lib, argv, modifiers): if len(argv) < 1: raise CmdLineInputError() lib.alert.remove_recipient(argv) def _nvset_to_str(nvset_obj): output = [] for nvpair_obj in nvset_obj: output.append("{key}={value}".format( key=nvpair_obj["name"], value=nvpair_obj["value"] )) return " ".join(output) def __description_attributes_to_str(obj): output = [] if obj.get("description"): output.append("Description: {desc}".format(desc=obj["description"])) if obj.get("instance_attributes"): output.append("Options: {attributes}".format( attributes=_nvset_to_str(obj["instance_attributes"]) )) if obj.get("meta_attributes"): output.append("Meta options: {attributes}".format( attributes=_nvset_to_str(obj["meta_attributes"]) )) return output def _alert_to_str(alert): content = [] content.extend(__description_attributes_to_str(alert)) recipients = [] for recipient in alert.get("recipient_list", []): recipients.extend( _recipient_to_str(recipient)) if recipients: content.append("Recipients:") content.extend(indent(recipients, 1)) return ["Alert: {alert_id} (path={path})".format( alert_id=alert["id"], path=alert["path"] )] + indent(content, 1) def _recipient_to_str(recipient): return ["Recipient: {id} (value={value})".format( value=recipient["value"], id=recipient["id"] )] + indent(__description_attributes_to_str(recipient), 1) def print_alert_config(lib, argv, modifiers): if argv: raise CmdLineInputError() print("Alerts:") alert_list = lib.alert.get_all_alerts() if alert_list: for alert in alert_list: print("\n".join(indent(_alert_to_str(alert), 1))) else: print(" No alerts defined") def print_alerts_in_json(lib, argv, dummy_modifiers): # This is used only by pcsd, will be removed in new architecture if argv: raise CmdLineInputError() print(json.dumps(lib.alert.get_all_alerts())) pcs-0.9.155/pcs/app.py000066400000000000000000000220711301012375000143710ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import getopt import os import sys import logging logging.basicConfig() from pcs import ( acl, booth, cluster, config, constraint, node, pcsd, prop, qdevice, quorum, resource, settings, status, stonith, usage, utils, alert, ) from pcs.cli.common import completion usefile = False filename = "" def main(argv=None): if completion.has_applicable_environment(os.environ): print(completion.make_suggestions( os.environ, usage.generate_completion_tree_from_usage() )) sys.exit() argv = argv if argv else sys.argv[1:] utils.subprocess_setup() global filename, usefile orig_argv = argv[:] utils.pcs_options = {} modified_argv = [] real_argv = [] try: # we change --cloneopt to "clone" for backwards compatibility new_argv = [] for arg in argv: if arg == "--cloneopt" or arg == "--clone": new_argv.append("clone") elif arg.startswith("--cloneopt="): new_argv.append("clone") new_argv.append(arg.split('=',1)[1]) else: new_argv.append(arg) argv = new_argv # we want to support optional arguments for --wait, so if an argument # is specified with --wait (ie. --wait=30) then we use them waitsecs = None new_argv = [] for arg in argv: if arg.startswith("--wait="): tempsecs = arg.replace("--wait=","") if len(tempsecs) > 0: waitsecs = tempsecs arg = "--wait" new_argv.append(arg) argv = new_argv # h = help, f = file, # p = password (cluster auth), u = user (cluster auth), # V = verbose (cluster verify) pcs_short_options = "hf:p:u:V" pcs_long_options = [ "debug", "version", "help", "fullhelp", "force", "skip-offline", "autocorrect", "interactive", "autodelete", "all", "full", "groups", "local", "wait", "config", "start", "enable", "disabled", "off", "pacemaker", "corosync", "no-default-ops", "defaults", "nodesc", "clone", "master", "name=", "group=", "node=", "from=", "to=", "after=", "before=", "transport=", "rrpmode=", "ipv6", "addr0=", "bcast0=", "mcast0=", "mcastport0=", "ttl0=", "broadcast0", "addr1=", "bcast1=", "mcast1=", "mcastport1=", "ttl1=", "broadcast1", "wait_for_all=", "auto_tie_breaker=", "last_man_standing=", "last_man_standing_window=", "token=", "token_coefficient=", "consensus=", "join=", "miss_count_const=", "fail_recv_const=", "corosync_conf=", "cluster_conf=", "booth-conf=", "booth-key=", "remote", "watchdog=", #in pcs status - do not display resorce status on inactive node "hide-inactive", ] # pull out negative number arguments and add them back after getopt prev_arg = "" for arg in argv: if len(arg) > 0 and arg[0] == "-": if arg[1:].isdigit() or arg[1:].startswith("INFINITY"): real_argv.append(arg) else: modified_argv.append(arg) else: # If previous argument required an argument, then this arg # should not be added back in if not prev_arg or (not (prev_arg[0] == "-" and prev_arg[1:] in pcs_short_options) and not (prev_arg[0:2] == "--" and (prev_arg[2:] + "=") in pcs_long_options)): real_argv.append(arg) modified_argv.append(arg) prev_arg = arg pcs_options, argv = getopt.gnu_getopt(modified_argv, pcs_short_options, pcs_long_options) except getopt.GetoptError as err: print(err) usage.main() sys.exit(1) argv = real_argv for o, a in pcs_options: if not o in utils.pcs_options: if o == "--watchdog": a = [a] utils.pcs_options[o] = a else: # If any options are a list then they've been entered twice which isn't valid if o != "--watchdog": utils.err("%s can only be used once" % o) else: utils.pcs_options[o].append(a) if o == "-h" or o == "--help": if len(argv) == 0: usage.main() sys.exit() else: argv = [argv[0], "help" ] + argv[1:] elif o == "-f": usefile = True filename = a utils.usefile = usefile utils.filename = filename elif o == "--corosync_conf": settings.corosync_conf_file = a elif o == "--cluster_conf": settings.cluster_conf_file = a elif o == "--version": print(settings.pcs_version) sys.exit() elif o == "--fullhelp": usage.full_usage() sys.exit() elif o == "--wait": utils.pcs_options[o] = waitsecs if len(argv) == 0: usage.main() sys.exit(1) # create a dummy logger # we do not have a log file for cli (yet), but library requires a logger logger = logging.getLogger("old_cli") logger.propagate = 0 logger.handlers = [] command = argv.pop(0) if (command == "-h" or command == "help"): usage.main() return cmd_map = { "resource": resource.resource_cmd, "cluster": cluster.cluster_cmd, "stonith": stonith.stonith_cmd, "property": prop.property_cmd, "constraint": constraint.constraint_cmd, "acl": lambda argv: acl.acl_cmd( utils.get_library_wrapper(), argv, utils.get_modificators() ), "status": status.status_cmd, "config": config.config_cmd, "pcsd": pcsd.pcsd_cmd, "node": node.node_cmd, "quorum": lambda argv: quorum.quorum_cmd( utils.get_library_wrapper(), argv, utils.get_modificators() ), "qdevice": lambda argv: qdevice.qdevice_cmd( utils.get_library_wrapper(), argv, utils.get_modificators() ), "alert": lambda args: alert.alert_cmd( utils.get_library_wrapper(), args, utils.get_modificators() ), "booth": lambda argv: booth.booth_cmd( utils.get_library_wrapper(), argv, utils.get_modificators() ), } if command not in cmd_map: usage.main() sys.exit(1) # root can run everything directly, also help can be displayed, # working on a local file also do not need to run under root if (os.getuid() == 0) or (argv and argv[0] == "help") or usefile: cmd_map[command](argv) return # specific commands need to be run under root account, pass them to pcsd # don't forget to allow each command in pcsd.rb in "post /run_pcs do" root_command_list = [ ['cluster', 'auth', '...'], ['cluster', 'corosync', '...'], ['cluster', 'destroy', '...'], ['cluster', 'disable', '...'], ['cluster', 'enable', '...'], ['cluster', 'node', '...'], ['cluster', 'pcsd-status', '...'], ['cluster', 'setup', '...'], ['cluster', 'start', '...'], ['cluster', 'stop', '...'], ['cluster', 'sync', '...'], # ['config', 'restore', '...'], # handled in config.config_restore ['pcsd', 'sync-certificates'], ['status', 'nodes', 'corosync-id'], ['status', 'nodes', 'pacemaker-id'], ['status', 'pcsd', '...'], ] argv_cmd = argv[:] argv_cmd.insert(0, command) for root_cmd in root_command_list: if ( (argv_cmd == root_cmd) or ( root_cmd[-1] == "..." and argv_cmd[:len(root_cmd)-1] == root_cmd[:-1] ) ): # handle interactivity of 'pcs cluster auth' if argv_cmd[0:2] == ["cluster", "auth"]: if "-u" not in utils.pcs_options: username = utils.get_terminal_input('Username: ') orig_argv.extend(["-u", username]) if "-p" not in utils.pcs_options: password = utils.get_terminal_password() orig_argv.extend(["-p", password]) # call the local pcsd err_msgs, exitcode, std_out, std_err = utils.call_local_pcsd( orig_argv, True ) if err_msgs: for msg in err_msgs: utils.err(msg, False) sys.exit(1) if std_out.strip(): print(std_out) if std_err.strip(): sys.stderr.write(std_err) sys.exit(exitcode) return cmd_map[command](argv) pcs-0.9.155/pcs/bash_completion.sh000066400000000000000000000020051301012375000167340ustar00rootroot00000000000000# bash completion for pcs _pcs_completion(){ LENGTHS=() for WORD in "${COMP_WORDS[@]}"; do LENGTHS+=(${#WORD}) done COMPREPLY=( $( \ env COMP_WORDS="${COMP_WORDS[*]}" \ COMP_LENGTHS="${LENGTHS[*]}" \ COMP_CWORD=$COMP_CWORD \ PCS_AUTO_COMPLETE=1 pcs \ ) ) #examples what we get: #pcs #COMP_WORDS: pcs COMP_LENGTHS: 3 #pcs co #COMP_WORDS: pcs co COMP_LENGTHS: 3 2 # pcs config #COMP_WORDS: pcs config COMP_LENGTHS: 3 6 # pcs config " #COMP_WORDS: pcs config " COMP_LENGTHS: 3 6 4 # pcs config "'\\n #COMP_WORDS: pcs config "'\\n COMP_LENGTHS: 3 6 5'" } # -o default # Use readline's default filename completion if the compspec generates no # matches. # -F function # The shell function function is executed in the current shell environment. # When it finishes, the possible completions are retrieved from the value of # the COMPREPLY array variable. complete -o default -F _pcs_completion pcs pcs-0.9.155/pcs/booth.py000066400000000000000000000053441301012375000147300ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import sys from pcs import usage from pcs import utils from pcs.cli.booth import command from pcs.cli.common.errors import CmdLineInputError from pcs.lib.errors import LibraryError from pcs.resource import resource_create, resource_remove, resource_restart def booth_cmd(lib, argv, modifiers): """ routes booth command """ if len(argv) < 1: usage.booth() sys.exit(1) sub_cmd, argv_next = argv[0], argv[1:] try: if sub_cmd == "help": usage.booth(argv) elif sub_cmd == "config": command.config_show(lib, argv_next, modifiers) elif sub_cmd == "setup": command.config_setup(lib, argv_next, modifiers) elif sub_cmd == "destroy": command.config_destroy(lib, argv_next, modifiers) elif sub_cmd == "ticket": if len(argv_next) < 1: raise CmdLineInputError() if argv_next[0] == "add": command.config_ticket_add(lib, argv_next[1:], modifiers) elif argv_next[0] == "remove": command.config_ticket_remove(lib, argv_next[1:], modifiers) elif argv_next[0] == "grant": command.ticket_grant(lib, argv_next[1:], modifiers) elif argv_next[0] == "revoke": command.ticket_revoke(lib, argv_next[1:], modifiers) else: raise CmdLineInputError() elif sub_cmd == "create": command.get_create_in_cluster(resource_create, resource_remove)( lib, argv_next, modifiers ) elif sub_cmd == "remove": command.get_remove_from_cluster(resource_remove)( lib, argv_next, modifiers ) elif sub_cmd == "restart": command.get_restart(resource_restart)(lib, argv_next, modifiers) elif sub_cmd == "sync": command.sync(lib, argv_next, modifiers) elif sub_cmd == "pull": command.pull(lib, argv_next, modifiers) elif sub_cmd == "enable": command.enable(lib, argv_next, modifiers) elif sub_cmd == "disable": command.disable(lib, argv_next, modifiers) elif sub_cmd == "start": command.start(lib, argv_next, modifiers) elif sub_cmd == "stop": command.stop(lib, argv_next, modifiers) elif sub_cmd == "status": command.status(lib, argv_next, modifiers) else: raise CmdLineInputError() except LibraryError as e: utils.process_library_reports(e.args) except CmdLineInputError as e: utils.exit_on_cmdline_input_errror(e, "booth", sub_cmd) pcs-0.9.155/pcs/cli/000077500000000000000000000000001301012375000140045ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/__init__.py000066400000000000000000000000001301012375000161030ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/booth/000077500000000000000000000000001301012375000151175ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/booth/__init__.py000066400000000000000000000000001301012375000172160ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/booth/command.py000066400000000000000000000120711301012375000171100ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.cli.common.errors import CmdLineInputError from pcs.cli.common.parse_args import group_by_keywords, prepare_options DEFAULT_BOOTH_NAME = "booth" def __get_name(modifiers): return modifiers["name"] if modifiers["name"] else DEFAULT_BOOTH_NAME def config_setup(lib, arg_list, modifiers): """ create booth config """ peers = group_by_keywords( arg_list, set(["sites", "arbitrators"]), keyword_repeat_allowed=False ) if "sites" not in peers or not peers["sites"]: raise CmdLineInputError() booth_config = [] for site in peers["sites"]: booth_config.append({"key": "site", "value": site, "details": []}) for arbitrator in peers["arbitrators"]: booth_config.append({ "key": "arbitrator", "value": arbitrator, "details": [], }) lib.booth.config_setup(booth_config, modifiers["force"]) def config_destroy(lib, arg_list, modifiers): """ destroy booth config """ if arg_list: raise CmdLineInputError() lib.booth.config_destroy(ignore_config_load_problems=modifiers["force"]) def config_show(lib, arg_list, modifiers): """ print booth config """ if len(arg_list) > 1: raise CmdLineInputError() node = None if not arg_list else arg_list[0] print(lib.booth.config_text(DEFAULT_BOOTH_NAME, node), end="") def config_ticket_add(lib, arg_list, modifiers): """ add ticket to current configuration """ if not arg_list: raise CmdLineInputError lib.booth.config_ticket_add( arg_list[0], prepare_options(arg_list[1:]), allow_unknown_options=modifiers["force"] ) def config_ticket_remove(lib, arg_list, modifiers): """ add ticket to current configuration """ if len(arg_list) != 1: raise CmdLineInputError lib.booth.config_ticket_remove(arg_list[0]) def ticket_operation(lib_call, arg_list, modifiers): site_ip = None if len(arg_list) == 2: site_ip = arg_list[1] elif len(arg_list) != 1: raise CmdLineInputError() ticket = arg_list[0] lib_call(__get_name(modifiers), ticket, site_ip) def ticket_revoke(lib, arg_list, modifiers): ticket_operation(lib.booth.ticket_revoke, arg_list, modifiers) def ticket_grant(lib, arg_list, modifiers): ticket_operation(lib.booth.ticket_grant, arg_list, modifiers) def get_create_in_cluster(resource_create, resource_remove): #TODO resource_remove is provisional hack until resources are not moved to #lib def create_in_cluster(lib, arg_list, modifiers): if len(arg_list) != 2 or arg_list[0] != "ip": raise CmdLineInputError() ip = arg_list[1] lib.booth.create_in_cluster( __get_name(modifiers), ip, resource_create, resource_remove, ) return create_in_cluster def get_remove_from_cluster(resource_remove): #TODO resource_remove is provisional hack until resources are not moved to #lib def remove_from_cluster(lib, arg_list, modifiers): if arg_list: raise CmdLineInputError() lib.booth.remove_from_cluster( __get_name(modifiers), resource_remove, modifiers["force"], ) return remove_from_cluster def get_restart(resource_restart): #TODO resource_restart is provisional hack until resources are not moved to #lib def restart(lib, arg_list, modifiers): if arg_list: raise CmdLineInputError() lib.booth.restart( __get_name(modifiers), resource_restart, modifiers["force"], ) return restart def sync(lib, arg_list, modifiers): if arg_list: raise CmdLineInputError() lib.booth.config_sync( DEFAULT_BOOTH_NAME, skip_offline_nodes=modifiers["skip_offline_nodes"] ) def enable(lib, arg_list, modifiers): if arg_list: raise CmdLineInputError() lib.booth.enable(DEFAULT_BOOTH_NAME) def disable(lib, arg_list, modifiers): if arg_list: raise CmdLineInputError() lib.booth.disable(DEFAULT_BOOTH_NAME) def start(lib, arg_list, modifiers): if arg_list: raise CmdLineInputError() lib.booth.start(DEFAULT_BOOTH_NAME) def stop(lib, arg_list, modifiers): if arg_list: raise CmdLineInputError() lib.booth.stop(DEFAULT_BOOTH_NAME) def pull(lib, arg_list, modifiers): if len(arg_list) != 1: raise CmdLineInputError() lib.booth.pull(arg_list[0], DEFAULT_BOOTH_NAME) def status(lib, arg_list, modifiers): if arg_list: raise CmdLineInputError() booth_status = lib.booth.status(DEFAULT_BOOTH_NAME) if booth_status.get("ticket"): print("TICKETS:") print(booth_status["ticket"]) if booth_status.get("peers"): print("PEERS:") print(booth_status["peers"]) if booth_status.get("status"): print("DAEMON STATUS:") print(booth_status["status"]) pcs-0.9.155/pcs/cli/booth/console_report.py000066400000000000000000000105111301012375000205240ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.common import report_codes as codes def format_booth_default(value, template): return "" if value in ("booth", "", None) else template.format(value) #Each value (callable taking report_item.info) returns string template. #Optionaly the template can contain placehodler {force} for next processing. #Placeholder {force} will be appended if is necessary and if is not presset CODE_TO_MESSAGE_BUILDER_MAP = { codes.BOOTH_LACK_OF_SITES: lambda info: "lack of sites for booth configuration (need 2 at least): sites {0}" .format(", ".join(info["sites"]) if info["sites"] else "missing") , codes.BOOTH_EVEN_PEERS_NUM: lambda info: "odd number of peers is required (entered {number} peers)" .format(**info) , codes.BOOTH_ADDRESS_DUPLICATION: lambda info: "duplicate address for booth configuration: {0}" .format(", ".join(info["addresses"])) , codes.BOOTH_CONFIG_UNEXPECTED_LINES: lambda info: "unexpected line appeard in config: \n{0}" .format("\n".join(info["line_list"])) , codes.BOOTH_INVALID_NAME: lambda info: "booth name '{name}' is not valid ({reason})" .format(**info) , codes.BOOTH_TICKET_NAME_INVALID: lambda info: "booth ticket name '{0}' is not valid, use alphanumeric chars or dash" .format(info["ticket_name"]) , codes.BOOTH_TICKET_DUPLICATE: lambda info: "booth ticket name '{ticket_name}' already exists in configuration" .format(**info) , codes.BOOTH_TICKET_DOES_NOT_EXIST: lambda info: "booth ticket name '{ticket_name}' does not exist" .format(**info) , codes.BOOTH_ALREADY_IN_CIB: lambda info: "booth instance '{name}' is already created as cluster resource" .format(**info) , codes.BOOTH_NOT_EXISTS_IN_CIB: lambda info: "booth instance '{name}' not found in cib" .format(**info) , codes.BOOTH_CONFIG_IS_USED: lambda info: "booth instance '{0}' is used{1}".format( info["name"], " {0}".format(info["detail"]) if info["detail"] else "", ) , codes.BOOTH_MULTIPLE_TIMES_IN_CIB: lambda info: "found more than one booth instance '{name}' in cib" .format(**info) , codes.BOOTH_CONFIG_DISTRIBUTION_STARTED: lambda info: "Sending booth configuration to cluster nodes..." , codes.BOOTH_CONFIG_ACCEPTED_BY_NODE: lambda info: "{node_info}Booth config{desc} saved.".format( desc=( "" if info["name_list"] in [None, [], ["booth"]] else "(s) ({0})".format(", ".join(info["name_list"])) ), node_info="{0}: ".format(info["node"]) if info["node"] else "" ) , codes.BOOTH_CONFIG_DISTRIBUTION_NODE_ERROR: lambda info: "Unable to save booth config{desc} on node '{node}': {reason}".format( desc=format_booth_default(info["name"], " ({0})"), **info ) , codes.BOOTH_CONFIG_READ_ERROR: lambda info: "Unable to read booth config{desc}.".format( desc=format_booth_default(info["name"], " ({0})") ) , codes.BOOTH_FETCHING_CONFIG_FROM_NODE: lambda info: "Fetching booth config{desc} from node '{node}'...".format( desc=format_booth_default(info["config"], " '{0}'"), **info ) , codes.BOOTH_DAEMON_STATUS_ERROR: lambda info: "unable to get status of booth daemon: {reason}".format(**info) , codes.BOOTH_TICKET_STATUS_ERROR: "unable to get status of booth tickets", codes.BOOTH_PEERS_STATUS_ERROR: "unable to get status of booth peers", codes.BOOTH_CANNOT_DETERMINE_LOCAL_SITE_IP: lambda info: "cannot determine local site ip, please specify site parameter" , codes.BOOTH_TICKET_OPERATION_FAILED: lambda info: ( "unable to {operation} booth ticket '{ticket_name}'" " for site '{site_ip}', reason: {reason}" ).format(**info) , codes.BOOTH_SKIPPING_CONFIG: lambda info: "Skipping config file '{config_file}': {reason}".format(**info) , codes.BOOTH_CANNOT_IDENTIFY_KEYFILE: "cannot identify authfile in booth configuration" , } pcs-0.9.155/pcs/cli/booth/env.py000066400000000000000000000074721301012375000162730ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os.path from pcs.cli.common import console_report from pcs.common import report_codes, env_file_role_codes as file_role_codes from pcs.lib.errors import LibraryEnvError def read_env_file(path): try: return { "content": open(path).read() if os.path.isfile(path) else None } except EnvironmentError as e: raise console_report.error( "Unable to read {0}: {1}".format(path, e.strerror) ) def write_env_file(env_file, file_path): try: f = open(file_path, "wb" if env_file.get("is_binary", False) else "w") f.write(env_file["content"]) f.close() except EnvironmentError as e: raise console_report.error( "Unable to write {0}: {1}".format(file_path, e.strerror) ) def process_no_existing_file_expectation(file_role, env_file, file_path): if( env_file["no_existing_file_expected"] and os.path.exists(file_path) ): msg = "{0} {1} already exists".format(file_role, file_path) if not env_file["can_overwrite_existing_file"]: raise console_report.error( "{0}, use --force to override".format(msg) ) console_report.warn(msg) def is_missing_file_report(report, file_role_code): return ( report.code == report_codes.FILE_DOES_NOT_EXIST and report.info["file_role"] == file_role_code ) def report_missing_file(file_role, file_path): console_report.error( "{0} '{1}' does not exist".format(file_role, file_path) ) def middleware_config(name, config_path, key_path): if config_path and not key_path: raise console_report.error( "With --booth-conf must be specified --booth-key as well" ) if key_path and not config_path: raise console_report.error( "With --booth-key must be specified --booth-conf as well" ) is_mocked_environment = config_path and key_path def create_booth_env(): if not is_mocked_environment: return {"name": name} return { "name": name, "config_file": read_env_file(config_path), "key_file": read_env_file(key_path), "key_path": key_path, } def flush(modified_env): if not is_mocked_environment: return if not modified_env: #TODO now this would not happen #for more information see comment in #pcs.cli.common.lib_wrapper.lib_env_to_cli_env raise console_report.error("Error during library communication") process_no_existing_file_expectation( "booth config file", modified_env["config_file"], config_path ) process_no_existing_file_expectation( "booth key file", modified_env["key_file"], key_path ) write_env_file(modified_env["key_file"], key_path) write_env_file(modified_env["config_file"], config_path) def apply(next_in_line, env, *args, **kwargs): env.booth = create_booth_env() try: result_of_next = next_in_line(env, *args, **kwargs) except LibraryEnvError as e: for report in e.args: if is_missing_file_report(report, file_role_codes.BOOTH_CONFIG): report_missing_file("Booth config file", config_path) e.sign_processed(report) if is_missing_file_report(report, file_role_codes.BOOTH_KEY): report_missing_file("Booth key file", key_path) e.sign_processed(report) raise e flush(env.booth["modified_env"]) return result_of_next return apply pcs-0.9.155/pcs/cli/booth/test/000077500000000000000000000000001301012375000160765ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/booth/test/__init__.py000066400000000000000000000000001301012375000201750ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/booth/test/test_command.py000066400000000000000000000031131301012375000211230ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.booth import command from pcs.test.tools.pcs_unittest import mock class ConfigSetupTest(TestCase): def test_call_lib_with_correct_args(self): lib = mock.MagicMock() lib.booth = mock.MagicMock() lib.booth.config_setup = mock.MagicMock() command.config_setup( lib, arg_list=[ "sites", "1.1.1.1", "2.2.2.2", "4.4.4.4", "arbitrators", "3.3.3.3" ], modifiers={ "force": False, } ) lib.booth.config_setup.assert_called_once_with( [ {"key": "site", "value": "1.1.1.1", "details": []}, {"key": "site", "value": "2.2.2.2", "details": []}, {"key": "site", "value": "4.4.4.4", "details": []}, {"key": "arbitrator", "value": "3.3.3.3", "details": []}, ], False ) class ConfigTicketAddTest(TestCase): def test_call_lib_with_ticket_name(self): lib = mock.MagicMock() lib.booth = mock.MagicMock() lib.booth.config_ticket_add = mock.MagicMock() command.config_ticket_add( lib, arg_list=["TICKET_A", "timeout=10"], modifiers={"force": True} ) lib.booth.config_ticket_add.assert_called_once_with( "TICKET_A", {"timeout": "10"}, allow_unknown_options=True ) pcs-0.9.155/pcs/cli/booth/test/test_env.py000066400000000000000000000077441301012375000203130ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.booth.env import middleware_config from pcs.common import report_codes, env_file_role_codes from pcs.lib.errors import LibraryEnvError, ReportItem from pcs.test.tools.pcs_unittest import mock class BoothConfTest(TestCase): @mock.patch("pcs.cli.booth.env.os.path.isfile") def test_sucessfully_care_about_local_file(self, mock_is_file): #setup, fixtures def next_in_line(env): env.booth["modified_env"] = { "config_file": { "content": "file content", "no_existing_file_expected": False, }, "key_file": { "content": "key file content", "no_existing_file_expected": False, } } return "call result" mock_is_file.return_value = True mock_env = mock.MagicMock() mock_open = mock.mock_open() with mock.patch( "pcs.cli.booth.env.open", mock_open, create=True ): #run tested code booth_conf_middleware = middleware_config( "booth-name", "/local/file/path.conf", "/local/file/path.key", ) self.assertEqual( "call result", booth_conf_middleware(next_in_line, mock_env) ) #assertions self.assertEqual(mock_is_file.mock_calls,[ mock.call("/local/file/path.conf"), mock.call("/local/file/path.key"), ]) self.assertEqual(mock_env.booth["name"], "booth-name") self.assertEqual(mock_env.booth["config_file"], {"content": ""}) self.assertEqual(mock_env.booth["key_file"], {"content": ""}) self.assertEqual(mock_open.mock_calls, [ mock.call(u'/local/file/path.conf'), mock.call().read(), mock.call(u'/local/file/path.key'), mock.call().read(), mock.call(u'/local/file/path.key', u'w'), mock.call().write(u'key file content'), mock.call().close(), mock.call(u'/local/file/path.conf', u'w'), mock.call().write(u'file content'), mock.call().close(), ]) @mock.patch("pcs.cli.booth.env.console_report") @mock.patch("pcs.cli.booth.env.os.path.isfile") def test_catch_exactly_his_exception( self, mock_is_file, mock_console_report ): next_in_line = mock.Mock(side_effect=LibraryEnvError( ReportItem.error(report_codes.FILE_DOES_NOT_EXIST, info={ "file_role": env_file_role_codes.BOOTH_CONFIG, }), ReportItem.error(report_codes.FILE_DOES_NOT_EXIST, info={ "file_role": env_file_role_codes.BOOTH_KEY, }), ReportItem.error("OTHER ERROR", info={}), )) mock_is_file.return_value = False mock_env = mock.MagicMock() #run tested code booth_conf_middleware = middleware_config( "booth-name", "/local/file/path.conf", "/local/file/path.key", ) raised_exception = [] def run_middleware(): try: booth_conf_middleware(next_in_line, mock_env) except Exception as e: raised_exception.append(e) raise e self.assertRaises(LibraryEnvError, run_middleware) self.assertEqual(1, len(raised_exception[0].unprocessed)) self.assertEqual("OTHER ERROR", raised_exception[0].unprocessed[0].code) self.assertEqual(mock_console_report.error.mock_calls, [ mock.call( "Booth config file '/local/file/path.conf' does not exist" ), mock.call( "Booth key file '/local/file/path.key' does not exist" ), ]) pcs-0.9.155/pcs/cli/booth/test/test_reports.py000066400000000000000000000101711301012375000212050ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.booth.console_report import CODE_TO_MESSAGE_BUILDER_MAP from pcs.common import report_codes as codes class BoothConfigAccetedByNodeTest(TestCase): def setUp(self): self.build = CODE_TO_MESSAGE_BUILDER_MAP[ codes.BOOTH_CONFIG_ACCEPTED_BY_NODE ] def test_crete_message_with_empty_name_list(self): self.assertEqual("Booth config saved.", self.build({ "node": None, "name_list": [], })) def test_crete_message_with_name_booth_only(self): self.assertEqual("Booth config saved.", self.build({ "node": None, "name_list": ["booth"], })) def test_crete_message_with_single_name(self): self.assertEqual("Booth config(s) (some) saved.", self.build({ "node": None, "name_list": ["some"], })) def test_crete_message_with_multiple_name(self): self.assertEqual("Booth config(s) (some, another) saved.", self.build({ "node": None, "name_list": ["some", "another"], })) def test_crete_message_with_empty_node(self): self.assertEqual( "node1: Booth config(s) (some, another) saved.", self.build({ "node": "node1", "name_list": ["some", "another"], }), ) class BoothConfigDistributionNodeErrorTest(TestCase): def setUp(self): self.build = CODE_TO_MESSAGE_BUILDER_MAP[ codes.BOOTH_CONFIG_DISTRIBUTION_NODE_ERROR ] def test_create_message_for_empty_name(self): self.assertEqual( "Unable to save booth config on node 'node1': reason1", self.build({ "node": "node1", "reason": "reason1", "name": None, }) ) def test_create_message_for_booth_name(self): self.assertEqual( "Unable to save booth config on node 'node1': reason1", self.build({ "node": "node1", "reason": "reason1", "name": "booth", }) ) def test_create_message_for_another_name(self): self.assertEqual( "Unable to save booth config (another) on node 'node1': reason1", self.build({ "node": "node1", "reason": "reason1", "name": "another", }) ) class BoothConfigReadErrorTest(TestCase): def setUp(self): self.build = CODE_TO_MESSAGE_BUILDER_MAP[ codes.BOOTH_CONFIG_READ_ERROR ] def test_create_message_for_empty_name(self): self.assertEqual("Unable to read booth config.", self.build({ "name": None, })) def test_create_message_for_booth_name(self): self.assertEqual("Unable to read booth config.", self.build({ "name": "booth", })) def test_create_message_for_another_name(self): self.assertEqual("Unable to read booth config (another).", self.build({ "name": "another", })) class BoothFetchingConfigFromNodeTest(TestCase): def setUp(self): self.build = CODE_TO_MESSAGE_BUILDER_MAP[ codes.BOOTH_FETCHING_CONFIG_FROM_NODE ] def test_create_message_for_empty_name(self): self.assertEqual( "Fetching booth config from node 'node1'...", self.build({ "config": None, "node": "node1", }) ) def test_create_message_for_booth_name(self): self.assertEqual( "Fetching booth config from node 'node1'...", self.build({ "config": "booth", "node": "node1", }) ) def test_create_message_for_another_name(self): self.assertEqual( "Fetching booth config 'another' from node 'node1'...", self.build({ "config": "another", "node": "node1", }) ) pcs-0.9.155/pcs/cli/common/000077500000000000000000000000001301012375000152745ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/common/__init__.py000066400000000000000000000000001301012375000173730ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/common/completion.py000066400000000000000000000060551301012375000200250ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) def has_applicable_environment(environment): """ dict environment - very likely os.environ """ return bool( all( key in environment for key in ["COMP_WORDS", "COMP_LENGTHS", "COMP_CWORD", "PCS_AUTO_COMPLETE"] ) and environment['PCS_AUTO_COMPLETE'].strip() not in ('0', '') and environment['COMP_CWORD'].isdigit() ) def make_suggestions(environment, suggestion_tree): """ dict environment - very likely os.environ dict suggestion_tree - {'acl': {'role': {'create': ...}}}... """ if not has_applicable_environment(environment): raise EnvironmentError("Environment is not completion read") try: typed_word_list = _split_words( environment["COMP_WORDS"], environment["COMP_LENGTHS"].split(" "), ) except EnvironmentError: return "" return "\n".join(_find_suggestions( suggestion_tree, typed_word_list, int(environment['COMP_CWORD']) )) def _split_words(joined_words, word_lengths): cursor_position = 0 words_string_len = len(joined_words) word_list = [] for length in word_lengths: if not length.isdigit(): raise EnvironmentError( "Length of word '{0}' is not digit".format(length) ) next_position = cursor_position + int(length) if next_position > words_string_len: raise EnvironmentError( "Expected lengths are bigger than word lengths" ) if( next_position != words_string_len and not joined_words[next_position].isspace() ): raise EnvironmentError("Words separator is not expected space") word_list.append(joined_words[cursor_position:next_position]) cursor_position = next_position + 1 if words_string_len > next_position: raise EnvironmentError("Expected lengths are smaller then word lengths") return word_list def _find_suggestions(suggestion_tree, typed_word_list, word_under_cursor_idx): if not 1 <= word_under_cursor_idx <= len(typed_word_list): return [] if len(typed_word_list) == word_under_cursor_idx: #not started type the last word yet word_under_cursor = '' else: word_under_cursor = typed_word_list[word_under_cursor_idx] words_for_current_cursor_position = _get_subcommands( suggestion_tree, typed_word_list[1:word_under_cursor_idx] ) return [ word for word in words_for_current_cursor_position if word.startswith(word_under_cursor) ] def _get_subcommands(suggestion_tree, previous_subcommand_list): subcommand_tree = suggestion_tree for subcommand in previous_subcommand_list: if subcommand not in subcommand_tree: return [] subcommand_tree = subcommand_tree[subcommand] return sorted(list(subcommand_tree.keys())) pcs-0.9.155/pcs/cli/common/console_report.py000066400000000000000000000535731301012375000207200ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import sys from functools import partial from pcs.common import report_codes as codes from collections import Iterable INSTANCE_SUFFIX = "@{0}" NODE_PREFIX = "{0}: " def warn(message): sys.stdout.write(format_message(message, "Warning: ")) def format_message(message, prefix): return "{0}{1}\n".format(prefix, message) def error(message): sys.stderr.write(format_message(message, "Error: ")) return SystemExit(1) def indent(line_list, indent_step=2): """ return line list where each line of input is prefixed by N spaces list of string line_list are original lines int indent_step is count of spaces for line prefix """ return [ "{0}{1}".format(" "*indent_step, line) if line else line for line in line_list ] def format_optional(value, template): return "" if not value else template.format(value) def service_operation_started(operation, info): return "{operation}{service}{instance_suffix}...".format( operation=operation, instance_suffix=format_optional(info["instance"], INSTANCE_SUFFIX), **info ) def service_operation_error(operation, info): return ( "{node_prefix}Unable to {operation} {service}{instance_suffix}:" " {reason}" ).format( operation=operation, instance_suffix=format_optional(info["instance"], INSTANCE_SUFFIX), node_prefix=format_optional(info["node"], NODE_PREFIX), **info ) def service_opration_success(operation, info): return "{node_prefix}{service}{instance_suffix} {operation}".format( operation=operation, instance_suffix=format_optional(info["instance"], INSTANCE_SUFFIX), node_prefix=format_optional(info["node"], NODE_PREFIX), **info ) def service_operation_skipped(operation, info): return ( "{node_prefix}not {operation}{service}{instance_suffix} - {reason}" ).format( operation=operation, instance_suffix=format_optional(info["instance"], INSTANCE_SUFFIX), node_prefix=format_optional(info["node"], NODE_PREFIX), **info ) #Each value (callable taking report_item.info) returns string template. #Optionaly the template can contain placehodler {force} for next processing. #Placeholder {force} will be appended if is necessary and if is not presset CODE_TO_MESSAGE_BUILDER_MAP = { codes.COMMON_ERROR: lambda info: info["text"], codes.COMMON_INFO: lambda info: info["text"], codes.EMPTY_RESOURCE_SET_LIST: "Resource set list is empty", codes.REQUIRED_OPTION_IS_MISSING: lambda info: "required option '{option_name}' is missing" .format(**info) , codes.INVALID_OPTION: lambda info: "invalid {desc}option '{option_name}', allowed options are: {allowed_values}" .format( desc=format_optional(info["option_type"], "{0} "), allowed_values=", ".join(info["allowed"]), **info ) , codes.INVALID_OPTION_VALUE: lambda info: "'{option_value}' is not a valid {option_name} value, use {hint}" .format( hint=( ", ".join(info["allowed_values"]) if ( isinstance(info["allowed_values"], Iterable) and not isinstance(info["allowed_values"], "".__class__) ) else info["allowed_values"] ), **info ) , codes.EMPTY_ID: lambda info: "{id_description} cannot be empty" .format(**info) , codes.INVALID_ID: lambda info: ( "invalid {id_description} '{id}', '{invalid_character}' " "is not a valid {desc}character for a {id_description}" ).format( desc="first " if info["is_first_char"] else "", **info ) , codes.INVALID_TIMEOUT_VALUE: lambda info: "'{timeout}' is not a valid number of seconds to wait" .format(**info) , codes.INVALID_SCORE: lambda info: "invalid score '{score}', use integer or INFINITY or -INFINITY" .format(**info) , codes.MULTIPLE_SCORE_OPTIONS: "you cannot specify multiple score options", codes.RUN_EXTERNAL_PROCESS_STARTED: lambda info: "Running: {command}\n{stdin_part}".format( stdin_part=format_optional( info["stdin"], "--Debug Input Start--\n{0}\n--Debug Input End--\n" ), **info ) , codes.RUN_EXTERNAL_PROCESS_FINISHED: lambda info: ( "Finished running: {command}\n" "Return value: {return_value}\n" "--Debug Stdout Start--\n" "{stdout}\n" "--Debug Stdout End--\n" "--Debug Stderr Start--\n" "{stderr}\n" "--Debug Stderr End--\n" ).format(**info) , codes.RUN_EXTERNAL_PROCESS_ERROR: lambda info: "unable to run command {command}: {reason}" .format(**info) , codes.NODE_COMMUNICATION_STARTED: lambda info: "Sending HTTP Request to: {target}\n{data_part}".format( data_part=format_optional( info["data"], "--Debug Input Start--\n{0}\n--Debug Input End--\n" ), **info ) , codes.NODE_COMMUNICATION_FINISHED: lambda info: ( "Finished calling: {target}\n" "Response Code: {response_code}\n" "--Debug Response Start--\n" "{response_data}\n" "--Debug Response End--\n" ).format(**info) , codes.NODE_COMMUNICATION_NOT_CONNECTED: lambda info: "Unable to connect to {node} ({reason})" .format(**info) , codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED: lambda info: ( "Unable to authenticate to {node} ({reason})," " try running 'pcs cluster auth'" ) .format(**info) , codes.NODE_COMMUNICATION_ERROR_PERMISSION_DENIED: lambda info: "{node}: Permission denied ({reason})" .format(**info) , codes.NODE_COMMUNICATION_ERROR_UNSUPPORTED_COMMAND: lambda info: "{node}: Unsupported command ({reason}), try upgrading pcsd" .format(**info) , codes.NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL: lambda info: "{node}: {reason}" .format(**info) , codes.NODE_COMMUNICATION_ERROR: lambda info: "Error connecting to {node} ({reason})" .format(**info) , codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT: lambda info: "Unable to connect to {node} ({reason})" .format(**info) , codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED: "Sending updated corosync.conf to nodes..." , codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE: lambda info: "{node}: Succeeded" .format(**info) , codes.COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR: lambda info: "{node}: Unable to set corosync config" .format(**info) , codes.COROSYNC_NOT_RUNNING_CHECK_STARTED: "Checking corosync is not running on nodes..." , codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR: lambda info: "{node}: Unable to check if corosync is not running" .format(**info) , codes.COROSYNC_NOT_RUNNING_ON_NODE: lambda info: "{node}: corosync is not running" .format(**info) , codes.COROSYNC_RUNNING_ON_NODE: lambda info: "{node}: corosync is running" .format(**info) , codes.COROSYNC_QUORUM_GET_STATUS_ERROR: lambda info: "Unable to get quorum status: {reason}" .format(**info) , codes.COROSYNC_QUORUM_SET_EXPECTED_VOTES_ERROR: lambda info: "Unable to set expected votes: {reason}" .format(**info) , codes.COROSYNC_CONFIG_RELOADED: "Corosync configuration reloaded", codes.COROSYNC_CONFIG_RELOAD_ERROR: lambda info: "Unable to reload corosync configuration: {reason}" .format(**info) , codes.UNABLE_TO_READ_COROSYNC_CONFIG: lambda info: "Unable to read {path}: {reason}" .format(**info) , codes.PARSE_ERROR_COROSYNC_CONF_MISSING_CLOSING_BRACE: "Unable to parse corosync config: missing closing brace" , codes.PARSE_ERROR_COROSYNC_CONF_UNEXPECTED_CLOSING_BRACE: "Unable to parse corosync config: unexpected closing brace" , codes.PARSE_ERROR_COROSYNC_CONF: "Unable to parse corosync config" , codes.COROSYNC_OPTIONS_INCOMPATIBLE_WITH_QDEVICE: lambda info: "These options cannot be set when the cluster uses a quorum device: {0}" .format(", ".join(sorted(info["options_names"]))) , codes.QDEVICE_ALREADY_DEFINED: "quorum device is already defined" , codes.QDEVICE_NOT_DEFINED: "no quorum device is defined in this cluster" , codes.QDEVICE_REMOVE_OR_CLUSTER_STOP_NEEDED: ( "You need to stop the cluster or remove qdevice from the cluster to" " continue" ), codes.QDEVICE_CLIENT_RELOAD_STARTED: "Reloading qdevice configuration on nodes..." , codes.QDEVICE_ALREADY_INITIALIZED: lambda info: "Quorum device '{model}' has been already initialized" .format(**info) , codes.QDEVICE_NOT_INITIALIZED: lambda info: "Quorum device '{model}' has not been initialized yet" .format(**info) , codes.QDEVICE_INITIALIZATION_SUCCESS: lambda info: "Quorum device '{model}' initialized" .format(**info) , codes.QDEVICE_INITIALIZATION_ERROR: lambda info: "Unable to initialize quorum device '{model}': {reason}" .format(**info) , codes.QDEVICE_CERTIFICATE_DISTRIBUTION_STARTED: "Setting up qdevice certificates on nodes..." , codes.QDEVICE_CERTIFICATE_ACCEPTED_BY_NODE: lambda info: "{node}: Succeeded" .format(**info) , codes.QDEVICE_CERTIFICATE_REMOVAL_STARTED: "Removing qdevice certificates from nodes..." , codes.QDEVICE_CERTIFICATE_REMOVED_FROM_NODE: lambda info: "{node}: Succeeded" .format(**info) , codes.QDEVICE_CERTIFICATE_IMPORT_ERROR: lambda info: "Unable to import quorum device certificate: {reason}" .format(**info) , codes.QDEVICE_CERTIFICATE_SIGN_ERROR: lambda info: "Unable to sign quorum device certificate: {reason}" .format(**info) , codes.QDEVICE_DESTROY_SUCCESS: lambda info: "Quorum device '{model}' configuration files removed" .format(**info) , codes.QDEVICE_DESTROY_ERROR: lambda info: "Unable to destroy quorum device '{model}': {reason}" .format(**info) , codes.QDEVICE_NOT_RUNNING: lambda info: "Quorum device '{model}' is not running" .format(**info) , codes.QDEVICE_GET_STATUS_ERROR: lambda info: "Unable to get status of quorum device '{model}': {reason}" .format(**info) , codes.QDEVICE_USED_BY_CLUSTERS: lambda info: "Quorum device is currently being used by cluster(s): {cluster_list}" .format(cluster_list=", ".join(info["clusters"])) , codes.CMAN_UNSUPPORTED_COMMAND: "This command is not supported on CMAN clusters" , codes.ID_ALREADY_EXISTS: lambda info: "'{id}' already exists" .format(**info) , codes.ID_NOT_FOUND: lambda info: "{desc}'{id}' does not exist" .format( desc=format_optional(info["id_description"], "{0} "), **info ) , codes.RESOURCE_DOES_NOT_EXIST: lambda info: "Resource '{resource_id}' does not exist" .format(**info) , codes.CIB_ACL_ROLE_IS_ALREADY_ASSIGNED_TO_TARGET: lambda info: "Role '{role_id}' is already asigned to '{target_id}'" .format(**info) , codes.CIB_ACL_ROLE_IS_NOT_ASSIGNED_TO_TARGET: lambda info: "Role '{role_id}' is not assigned to '{target_id}'" .format(**info) , codes.CIB_ACL_TARGET_ALREADY_EXISTS: lambda info: "'{target_id}' already exists" .format(**info) , codes.CIB_LOAD_ERROR: "unable to get cib", codes.CIB_LOAD_ERROR_SCOPE_MISSING: lambda info: "unable to get cib, scope '{scope}' not present in cib" .format(**info) , codes.CIB_LOAD_ERROR_BAD_FORMAT: "unable to get cib, xml does not conform to the schema" , codes.CIB_CANNOT_FIND_MANDATORY_SECTION: lambda info: "Unable to get {section} section of cib" .format(**info) , codes.CIB_PUSH_ERROR: lambda info: "Unable to update cib\n{reason}\n{pushed_cib}" .format(**info) , codes.CRM_MON_ERROR: "error running crm_mon, is pacemaker running?" , codes.BAD_CLUSTER_STATE_FORMAT: "cannot load cluster status, xml does not conform to the schema" , codes.RESOURCE_WAIT_NOT_SUPPORTED: "crm_resource does not support --wait, please upgrade pacemaker" , codes.RESOURCE_WAIT_TIMED_OUT: lambda info: "waiting timeout\n\n{reason}" .format(**info) , codes.RESOURCE_WAIT_ERROR: lambda info: "{reason}" .format(**info) , codes.RESOURCE_CLEANUP_ERROR: lambda info: ( "Unable to cleanup resource: {resource}\n{reason}" if info["resource"] else "Unexpected error occured. 'crm_resource -C' error:\n{reason}" ).format(**info) , codes.RESOURCE_CLEANUP_TOO_TIME_CONSUMING: lambda info: ( "Cleaning up all resources on all nodes will execute more " "than {threshold} operations in the cluster, which may " "negatively impact the responsiveness of the cluster. " "Consider specifying resource and/or node" ).format(**info) , codes.NODE_NOT_FOUND: lambda info: "node '{node}' does not appear to exist in configuration" .format(**info) , codes.PACEMAKER_LOCAL_NODE_NAME_NOT_FOUND: lambda info: "unable to get local node name from pacemaker: {reason}" .format(**info) , codes.RRP_ACTIVE_NOT_SUPPORTED: "using a RRP mode of 'active' is not supported or tested" , codes.IGNORED_CMAN_UNSUPPORTED_OPTION: lambda info: "{option_name} ignored as it is not supported on CMAN clusters" .format(**info) , codes.NON_UDP_TRANSPORT_ADDR_MISMATCH: "--addr0 and --addr1 can only be used with --transport=udp" , codes.CMAN_UDPU_RESTART_REQUIRED: ( "Using udpu transport on a CMAN cluster," " cluster restart is required after node add or remove" ), codes.CMAN_BROADCAST_ALL_RINGS: ( "Enabling broadcast for all rings as CMAN does not support" " broadcast in only one ring" ), codes.SERVICE_START_STARTED: partial(service_operation_started, "Starting"), codes.SERVICE_START_ERROR: partial(service_operation_error, "start"), codes.SERVICE_START_SUCCESS: partial(service_opration_success, "started"), codes.SERVICE_START_SKIPPED: partial(service_operation_skipped, "starting"), codes.SERVICE_STOP_STARTED: partial(service_operation_started, "Stopping"), codes.SERVICE_STOP_ERROR: partial(service_operation_error, "stop"), codes.SERVICE_STOP_SUCCESS: partial(service_opration_success, "stopped"), codes.SERVICE_ENABLE_STARTED: partial( service_operation_started, "Enabling" ), codes.SERVICE_ENABLE_ERROR: partial(service_operation_error, "enable"), codes.SERVICE_ENABLE_SUCCESS: partial(service_opration_success, "enabled"), codes.SERVICE_ENABLE_SKIPPED: partial( service_operation_skipped, "enabling" ), codes.SERVICE_DISABLE_STARTED: partial(service_operation_started, "Disabling") , codes.SERVICE_DISABLE_ERROR: partial(service_operation_error, "disable"), codes.SERVICE_DISABLE_SUCCESS: partial(service_opration_success, "disabled"), codes.SERVICE_KILL_ERROR: lambda info: "Unable to kill {service_list}: {reason}" .format( service_list=", ".join(info["services"]), **info ) , codes.SERVICE_KILL_SUCCESS: lambda info: "{services_list} killed" .format( service_list=", ".join(info["services"]), **info ) , codes.UNABLE_TO_GET_AGENT_METADATA: lambda info: ( "Agent '{agent}' is not installed or does not provide valid" " metadata: {reason}" ).format(**info) , codes.INVALID_RESOURCE_AGENT_NAME: lambda info: ( "Invalid resource agent name '{name}'." " Use standard:provider:type or standard:type." " List of standards and providers can be obtained by using commands" " 'pcs resource standards' and 'pcs resource providers'" ) .format(**info) , codes.AGENT_NAME_GUESS_FOUND_MORE_THAN_ONE: lambda info: ( "Multiple agents match '{agent}'" ", please specify full name: {possible_agents_str}" ).format(**info) , codes.AGENT_NAME_GUESS_FOUND_NONE: lambda info: "Unable to find agent '{agent}', try specifying its full name" .format(**info) , codes.AGENT_NAME_GUESSED: lambda info: "Assumed agent name '{guessed_name}' (deduced from '{entered_name}')" .format(**info) , codes.OMITTING_NODE: lambda info: "Omitting node '{node}'" .format(**info) , codes.SBD_CHECK_STARTED: "Running SBD pre-enabling checks...", codes.SBD_CHECK_SUCCESS: lambda info: "{node}: SBD pre-enabling checks done" .format(**info) , codes.SBD_CONFIG_DISTRIBUTION_STARTED: "Distributing SBD config...", codes.SBD_CONFIG_ACCEPTED_BY_NODE: lambda info: "{node}: SBD config saved" .format(**info) , codes.UNABLE_TO_GET_SBD_CONFIG: lambda info: "Unable to get SBD configuration from node '{node}'{reason_suffix}" .format( reason_suffix=format_optional(info["reason"], ": {0}"), **info ) , codes.SBD_ENABLING_STARTED: lambda info: "Enabling SBD service..." .format(**info) , codes.SBD_DISABLING_STARTED: "Disabling SBD service...", codes.INVALID_RESPONSE_FORMAT: lambda info: "{node}: Invalid format of response" .format(**info) , codes.SBD_NOT_INSTALLED: lambda info: "SBD is not installed on node '{node}'" .format(**info) , codes.WATCHDOG_NOT_FOUND: lambda info: "Watchdog '{watchdog}' does not exist on node '{node}'" .format(**info) , codes.WATCHDOG_INVALID: lambda info: "Watchdog path '{watchdog}' is invalid." .format(**info) , codes.UNABLE_TO_GET_SBD_STATUS: lambda info: "Unable to get status of SBD from node '{node}'{reason_suffix}" .format( reason_suffix=format_optional(info["reason"], ": {0}"), **info ) , codes.CLUSTER_RESTART_REQUIRED_TO_APPLY_CHANGES: "Cluster restart is required in order to apply these changes." , codes.CIB_ALERT_RECIPIENT_ALREADY_EXISTS: lambda info: "Recipient '{recipient}' in alert '{alert}' already exists" .format(**info) , codes.CIB_ALERT_RECIPIENT_VALUE_INVALID: lambda info: "Recipient value '{recipient}' is not valid." .format(**info) , codes.CIB_ALERT_NOT_FOUND: lambda info: "Alert '{alert}' not found." .format(**info) , codes.CIB_UPGRADE_SUCCESSFUL: lambda info: "CIB has been upgraded to the latest schema version." .format(**info) , codes.CIB_UPGRADE_FAILED: lambda info: "Upgrading of CIB to the latest schema failed: {reason}" .format(**info) , codes.CIB_UPGRADE_FAILED_TO_MINIMAL_REQUIRED_VERSION: lambda info: ( "Unable to upgrade CIB to required schema version" " {required_version} or higher. Current version is" " {current_version}. Newer version of pacemaker is needed." ) .format(**info) , codes.FILE_ALREADY_EXISTS: lambda info: "{node_prefix}{role_prefix}file {file_path} already exists" .format( node_prefix=format_optional(info["node"], NODE_PREFIX), role_prefix=format_optional(info["file_role"], "{0} "), **info ) , codes.FILE_DOES_NOT_EXIST: lambda info: "{file_role} file {file_path} does not exist" .format(**info) , codes.FILE_IO_ERROR: lambda info: "unable to {operation} {file_role}{path_desc}: {reason}" .format( path_desc=format_optional(info["file_path"], " '{0}'"), **info ) , codes.UNABLE_TO_DETERMINE_USER_UID: lambda info: "Unable to determine uid of user '{user}'" .format(**info) , codes.UNABLE_TO_DETERMINE_GROUP_GID: lambda info: "Unable to determine gid of group '{group}'" .format(**info) , codes.UNSUPPORTED_OPERATION_ON_NON_SYSTEMD_SYSTEMS: "unsupported operation on non systemd systems" , codes.LIVE_ENVIRONMENT_REQUIRED: lambda info: "This command does not support {forbidden_options}" .format(forbidden_options=", ".join(info["forbidden_options"])) , codes.COROSYNC_QUORUM_CANNOT_DISABLE_ATB_DUE_TO_SBD: lambda info: "unable to disable auto_tie_breaker: SBD fencing will have no effect" .format(**info) , codes.SBD_REQUIRES_ATB: lambda info: "auto_tie_breaker quorum option will be enabled to make SBD fencing " "effective. Cluster has to be offline to be able to make this change." , codes.CLUSTER_CONF_LOAD_ERROR_INVALID_FORMAT: lambda info: "unable to get cluster.conf: {reason}" .format(**info) , codes.CLUSTER_CONF_READ_ERROR: lambda info: "Unable to read {path}: {reason}" .format(**info) , } pcs-0.9.155/pcs/cli/common/env.py000066400000000000000000000007421301012375000164410ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) class Env(object): #pylint: disable=too-many-instance-attributes def __init__(self): self.cib_data = None self.cib_upgraded = False self.user = None self.groups = None self.corosync_conf_data = None self.booth = None self.auth_tokens_getter = None self.debug = False self.cluster_conf_data = None pcs-0.9.155/pcs/cli/common/errors.py000066400000000000000000000012101301012375000171540ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) class CmdLineInputError(Exception): """ Exception express that user entered incorrect commad in command line. """ def __init__(self, message=None): """ string message explain what was wrong with entered command The routine which handles this exception behaves according to whether the message was specified (prints this message to user) or not (prints appropriate part of documentation) """ super(CmdLineInputError, self).__init__(message) self.message = message pcs-0.9.155/pcs/cli/common/lib_wrapper.py000066400000000000000000000237221301012375000201620ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import logging import sys from collections import namedtuple from pcs.cli.common import middleware from pcs.cli.common.reports import ( LibraryReportProcessorToConsole, process_library_reports ) from pcs.lib.commands import ( acl, alert, booth, qdevice, quorum, resource_agent, sbd, stonith_agent, ) from pcs.lib.commands.constraint import ( colocation as constraint_colocation, order as constraint_order, ticket as constraint_ticket ) from pcs.lib.env import LibraryEnvironment from pcs.lib.errors import LibraryEnvError _CACHE = {} def wrapper(dictionary): return namedtuple('wrapper', dictionary.keys())(**dictionary) def cli_env_to_lib_env(cli_env): return LibraryEnvironment( logging.getLogger("old_cli"), LibraryReportProcessorToConsole(cli_env.debug), cli_env.user, cli_env.groups, cli_env.cib_data, cli_env.corosync_conf_data, booth=cli_env.booth, auth_tokens_getter=cli_env.auth_tokens_getter, cluster_conf_data=cli_env.cluster_conf_data, ) def lib_env_to_cli_env(lib_env, cli_env): if not lib_env.is_cib_live: cli_env.cib_data = lib_env._get_cib_xml() cli_env.cib_upgraded = lib_env.cib_upgraded if not lib_env.is_corosync_conf_live: cli_env.corosync_conf_data = lib_env.get_corosync_conf_data() if not lib_env.is_cluster_conf_live: cli_env.cluster_conf_data = lib_env.get_cluster_conf_data() #TODO #now we know: if is in cli_env booth is in lib_env as well #when we communicate with the library over the network we will need extra #sanitization here #this applies generally, not only for booth #corosync_conf and cib suffers with this problem as well but in this cases #it is dangerously hidden: when inconsistency between cli and lib #environment inconsitency occurs, original content is put to file (which is #wrong) if cli_env.booth: cli_env.booth["modified_env"] = lib_env.booth.export() return cli_env def bind(cli_env, run_with_middleware, run_library_command): def run(cli_env, *args, **kwargs): lib_env = cli_env_to_lib_env(cli_env) lib_call_result = run_library_command(lib_env, *args, **kwargs) #midlewares needs finish its work and they see only cli_env #so we need reflect some changes to cli_env lib_env_to_cli_env(lib_env, cli_env) return lib_call_result def decorated_run(*args, **kwargs): try: return run_with_middleware(run, cli_env, *args, **kwargs) except LibraryEnvError as e: process_library_reports(e.unprocessed) #TODO we use explicit exit here - process_library_reports stil has #possibility to not exit - it will need deeper rethinking sys.exit(1) return decorated_run def bind_all(env, run_with_middleware, dictionary): return wrapper(dict( (exposed_fn, bind(env, run_with_middleware, library_fn)) for exposed_fn, library_fn in dictionary.items() )) def get_module(env, middleware_factory, name): if name not in _CACHE: _CACHE[name] = load_module(env, middleware_factory, name) return _CACHE[name] def load_module(env, middleware_factory, name): if name == "acl": return bind_all( env, middleware.build(middleware_factory.cib), { "create_role": acl.create_role, "remove_role": acl.remove_role, "assign_role_not_specific": acl.assign_role_not_specific, "assign_role_to_target": acl.assign_role_to_target, "assign_role_to_group": acl.assign_role_to_group, "unassign_role_not_specific": acl.unassign_role_not_specific, "unassign_role_from_target": acl.unassign_role_from_target, "unassign_role_from_group": acl.unassign_role_from_group, "create_target": acl.create_target, "create_group": acl.create_group, "remove_target": acl.remove_target, "remove_group": acl.remove_group, "add_permission": acl.add_permission, "remove_permission": acl.remove_permission, "get_config": acl.get_config, } ) if name == "alert": return bind_all( env, middleware.build(middleware_factory.cib), { "create_alert": alert.create_alert, "update_alert": alert.update_alert, "remove_alert": alert.remove_alert, "add_recipient": alert.add_recipient, "update_recipient": alert.update_recipient, "remove_recipient": alert.remove_recipient, "get_all_alerts": alert.get_all_alerts, } ) if name == "booth": return bind_all( env, middleware.build( middleware_factory.booth_conf, middleware_factory.cib ), { "config_setup": booth.config_setup, "config_destroy": booth.config_destroy, "config_text": booth.config_text, "config_ticket_add": booth.config_ticket_add, "config_ticket_remove": booth.config_ticket_remove, "create_in_cluster": booth.create_in_cluster, "remove_from_cluster": booth.remove_from_cluster, "restart": booth.restart, "config_sync": booth.config_sync, "enable": booth.enable_booth, "disable": booth.disable_booth, "start": booth.start_booth, "stop": booth.stop_booth, "pull": booth.pull_config, "status": booth.get_status, "ticket_grant": booth.ticket_grant, "ticket_revoke": booth.ticket_revoke, } ) if name == 'constraint_colocation': return bind_all( env, middleware.build(middleware_factory.cib), { 'set': constraint_colocation.create_with_set, 'show': constraint_colocation.show, } ) if name == 'constraint_order': return bind_all( env, middleware.build(middleware_factory.cib), { 'set': constraint_order.create_with_set, 'show': constraint_order.show, } ) if name == 'constraint_ticket': return bind_all( env, middleware.build(middleware_factory.cib), { 'set': constraint_ticket.create_with_set, 'show': constraint_ticket.show, 'add': constraint_ticket.create, 'remove': constraint_ticket.remove, } ) if name == "qdevice": return bind_all( env, middleware.build(), { "status": qdevice.qdevice_status_text, "setup": qdevice.qdevice_setup, "destroy": qdevice.qdevice_destroy, "start": qdevice.qdevice_start, "stop": qdevice.qdevice_stop, "kill": qdevice.qdevice_kill, "enable": qdevice.qdevice_enable, "disable": qdevice.qdevice_disable, # following commands are internal use only, called from pcsd "client_net_setup": qdevice.client_net_setup, "client_net_import_certificate": qdevice.client_net_import_certificate, "client_net_destroy": qdevice.client_net_destroy, "sign_net_cert_request": qdevice.qdevice_net_sign_certificate_request, } ) if name == "quorum": return bind_all( env, middleware.build(middleware_factory.corosync_conf_existing), { "add_device": quorum.add_device, "get_config": quorum.get_config, "remove_device": quorum.remove_device, "set_expected_votes_live": quorum.set_expected_votes_live, "set_options": quorum.set_options, "status": quorum.status_text, "status_device": quorum.status_device_text, "update_device": quorum.update_device, } ) if name == "resource_agent": return bind_all( env, middleware.build(), { "describe_agent": resource_agent.describe_agent, "list_agents": resource_agent.list_agents, "list_agents_for_standard_and_provider": resource_agent.list_agents_for_standard_and_provider, "list_ocf_providers": resource_agent.list_ocf_providers, "list_standards": resource_agent.list_standards, } ) if name == "sbd": return bind_all( env, middleware.build(), { "enable_sbd": sbd.enable_sbd, "disable_sbd": sbd.disable_sbd, "get_cluster_sbd_status": sbd.get_cluster_sbd_status, "get_cluster_sbd_config": sbd.get_cluster_sbd_config, "get_local_sbd_config": sbd.get_local_sbd_config, } ) if name == "stonith_agent": return bind_all( env, middleware.build(), { "describe_agent": stonith_agent.describe_agent, "list_agents": stonith_agent.list_agents, } ) raise Exception("No library part '{0}'".format(name)) class Library(object): def __init__(self, env, middleware_factory): self.env = env self.middleware_factory = middleware_factory def __getattr__(self, name): return get_module(self.env, self.middleware_factory, name) pcs-0.9.155/pcs/cli/common/middleware.py000066400000000000000000000052351301012375000177700ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from collections import namedtuple from functools import partial from pcs.cli.common import console_report def build(*middleware_list): def run(command, env, *args, **kwargs): next_in_line = command for next_command in reversed(middleware_list): next_in_line = partial(next_command, next_in_line) return next_in_line(env, *args, **kwargs) return run def cib(use_local_cib, load_cib_content, write_cib): """ return configured middleware that cares about local cib bool use_local_cib is flag if local cib was required callable load_cib_content returns local cib content, take no params callable write_cib put content of cib to required place """ def apply(next_in_line, env, *args, **kwargs): if use_local_cib: original_content = load_cib_content() env.cib_data = original_content result_of_next = next_in_line(env, *args, **kwargs) if use_local_cib and env.cib_data != original_content: write_cib(env.cib_data, env.cib_upgraded) return result_of_next return apply def corosync_conf_existing(local_file_path): def apply(next_in_line, env, *args, **kwargs): if local_file_path: try: env.corosync_conf_data = open(local_file_path).read() except EnvironmentError as e: raise console_report.error("Unable to read {0}: {1}".format( local_file_path, e.strerror )) result_of_next = next_in_line(env, *args, **kwargs) if local_file_path: try: f = open(local_file_path, "w") f.write(env.corosync_conf_data) f.close() except EnvironmentError as e: raise console_report.error("Unable to write {0}: {1}".format( local_file_path, e.strerror )) return result_of_next return apply def cluster_conf_read_only(local_file_path): def apply(next_in_line, env, *args, **kwargs): if local_file_path: try: env.cluster_conf_data = open(local_file_path).read() except EnvironmentError as e: raise console_report.error("Unable to read {0}: {1}".format( local_file_path, e.strerror )) return next_in_line(env, *args, **kwargs) return apply def create_middleware_factory(**kwargs): return namedtuple('MiddlewareFactory', kwargs.keys())(**kwargs) pcs-0.9.155/pcs/cli/common/parse_args.py000066400000000000000000000032601301012375000177750ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.cli.common.errors import CmdLineInputError def split_list(arg_list, separator): """return list of list of arg_list using separator as delimiter""" separator_indexes = [i for i, x in enumerate(arg_list) if x == separator] bounds = zip([0]+[i+1 for i in separator_indexes], separator_indexes+[None]) return [arg_list[i:j] for i, j in bounds] def prepare_options(cmdline_args): """return dictionary of options from comandline key=value args""" options = dict() for arg in cmdline_args: if "=" not in arg: raise CmdLineInputError("missing value of '{0}' option".format(arg)) if arg.startswith("="): raise CmdLineInputError("missing key in '{0}' option".format(arg)) name, value = arg.split("=", 1) options[name] = value return options def group_by_keywords( arg_list, keyword_set, implicit_first_keyword=None, keyword_repeat_allowed=True, ): groups = dict([(keyword, []) for keyword in keyword_set]) if implicit_first_keyword: groups[implicit_first_keyword] = [] if not arg_list: return groups used_keywords = [] if implicit_first_keyword: used_keywords.append(implicit_first_keyword) elif arg_list[0] not in keyword_set: raise CmdLineInputError() for arg in arg_list: if arg in list(groups.keys()): if arg in used_keywords and not keyword_repeat_allowed: raise CmdLineInputError() used_keywords.append(arg) else: groups[used_keywords[-1]].append(arg) return groups pcs-0.9.155/pcs/cli/common/reports.py000066400000000000000000000071101301012375000173430ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import sys from functools import partial from pcs.cli.booth.console_report import ( CODE_TO_MESSAGE_BUILDER_MAP as BOOTH_CODE_TO_MESSAGE_BUILDER_MAP ) from pcs.cli.common.console_report import CODE_TO_MESSAGE_BUILDER_MAP from pcs.cli.constraint_all.console_report import ( CODE_TO_MESSAGE_BUILDER_MAP as CONSTRAINT_CODE_TO_MESSAGE_BUILDER_MAP ) from pcs.common import report_codes as codes from pcs.lib.errors import LibraryError, ReportItemSeverity __CODE_BUILDER_MAP = {} __CODE_BUILDER_MAP.update(CODE_TO_MESSAGE_BUILDER_MAP) __CODE_BUILDER_MAP.update(CONSTRAINT_CODE_TO_MESSAGE_BUILDER_MAP) __CODE_BUILDER_MAP.update(BOOTH_CODE_TO_MESSAGE_BUILDER_MAP) def build_default_message_from_report(report_item, force_text): return "Unknown report: {0} info: {1}{2}".format( report_item.code, str(report_item.info), force_text, ) def build_message_from_report(code_builder_map, report_item, force_text=""): if report_item.code not in code_builder_map: return build_default_message_from_report(report_item, force_text) template = code_builder_map[report_item.code] #Sometimes report item info is not needed for message building. #In this case template is string. Otherwise, template is callable. if callable(template): try: template = template(report_item.info) except(TypeError, KeyError): return build_default_message_from_report(report_item, force_text) #Message can contain {force} placeholder if there is need to have it on #specific position. Otherwise is appended to the end (if necessary). This #removes the need to explicitly specify placeholder for each message. if force_text and "{force}" not in template: template += "{force}" return template.format(force=force_text) build_report_message = partial(build_message_from_report, __CODE_BUILDER_MAP) class LibraryReportProcessorToConsole(object): def __init__(self, debug=False): self.debug = debug def process(self, report_item): self.process_list([report_item]) def process_list(self, report_item_list): errors = [] for report_item in report_item_list: if report_item.severity == ReportItemSeverity.ERROR: errors.append(report_item) elif report_item.severity == ReportItemSeverity.WARNING: print("Warning: " + build_report_message(report_item)) elif self.debug or report_item.severity != ReportItemSeverity.DEBUG: print(build_report_message(report_item)) if errors: raise LibraryError(*errors) def _prepare_force_text(report_item): if report_item.forceable == codes.SKIP_OFFLINE_NODES: return ", use --skip-offline to override" return ", use --force to override" if report_item.forceable else "" def process_library_reports(report_item_list): """ report_item_list list of ReportItem """ critical_error = False for report_item in report_item_list: if report_item.severity == ReportItemSeverity.WARNING: print("Warning: " + build_report_message(report_item)) continue if report_item.severity != ReportItemSeverity.ERROR: print(build_report_message(report_item)) continue sys.stderr.write('Error: {0}\n'.format(build_report_message( report_item, _prepare_force_text(report_item) ))) critical_error = True if critical_error: sys.exit(1) pcs-0.9.155/pcs/cli/common/test/000077500000000000000000000000001301012375000162535ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/common/test/__init__.py000066400000000000000000000000001301012375000203520ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/common/test/test_completion.py000066400000000000000000000115111301012375000220340ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.common.completion import ( _find_suggestions, has_applicable_environment, make_suggestions, _split_words, ) tree = { "resource": { "op": { "add": {}, "defaults": {}, "remove": {}, }, "clone": {}, }, "cluster": { "auth": {}, "cib": {}, } } class SuggestionTest(TestCase): def test_suggest_nothing_when_cursor_on_first_word(self): self.assertEqual([], _find_suggestions(tree, ['pcs'], 0)) self.assertEqual([], _find_suggestions(tree, ['pcs', 'resource'], 0)) def test_suggest_nothing_when_cursor_possition_out_of_range(self): self.assertEqual([], _find_suggestions(tree, ['pcs', 'resource'], 3)) def test_suggest_when_last_word_not_started(self): self.assertEqual( ["clone", "op"], _find_suggestions(tree, ['pcs', 'resource'], 2) ) def test_suggest_when_last_word_started(self): self.assertEqual( ["clone"], _find_suggestions(tree, ['pcs', 'resource', 'c'], 2) ) def test_suggest_when_cursor_on_word_amid(self): self.assertEqual( ["clone"], _find_suggestions(tree, ['pcs', 'resource', 'c', 'add'], 2) ) def test_suggest_nothing_when_previously_typed_word_not_match(self): self.assertEqual( [], _find_suggestions(tree, ['pcs', 'invalid', 'c'], 2) ) class HasCompletionEnvironmentTest(TestCase): def test_returns_false_if_environment_inapplicable(self): inapplicable_environments = [ { 'COMP_CWORD': '1', 'PCS_AUTO_COMPLETE': '1', }, { 'COMP_WORDS': 'pcs resource', 'PCS_AUTO_COMPLETE': '1', }, { 'COMP_WORDS': 'pcs resource', 'COMP_CWORD': '1', }, { 'COMP_WORDS': 'pcs resource', 'COMP_CWORD': '1', 'PCS_AUTO_COMPLETE': '0', }, { 'COMP_WORDS': 'pcs resource', 'COMP_CWORD': '1a', 'PCS_AUTO_COMPLETE': '1', }, { 'COMP_WORDS': 'pcs resource', 'COMP_CWORD': '1', 'PCS_AUTO_COMPLETE': '1', }, ] for environment in inapplicable_environments: self.assertFalse( has_applicable_environment(environment), 'environment evaluated as applicable (should not be): ' +repr(environment) ) def test_returns_true_if_environment_is_set(self): self.assertTrue(has_applicable_environment({ "COMP_WORDS": "pcs resource", "COMP_CWORD": '1', "COMP_LENGTHS": "3 8", "PCS_AUTO_COMPLETE": "1", })) class MakeSuggestionsEnvironment(TestCase): def test_raises_for_incomlete_environment(self): self.assertRaises( EnvironmentError, lambda: make_suggestions( { 'COMP_CWORD': '1', 'PCS_AUTO_COMPLETE': '1', }, suggestion_tree=tree ) ) def test_suggest_on_correct_environment(self): self.assertEqual( "clone\nop", make_suggestions( { "COMP_WORDS": "pcs resource", "COMP_CWORD": "2", "COMP_LENGTHS": "3 8", "PCS_AUTO_COMPLETE": "1", }, suggestion_tree=tree ) ) class SplitWordsTest(TestCase): def test_return_word_list_on_compatible_words_and_lenght(self): self.assertEqual( ["pcs", "resource", "op", "a"], _split_words("pcs resource op a", ["3", "8", "2", "1"]) ) def test_refuse_when_no_int_in_lengths(self): self.assertRaises( EnvironmentError, lambda: _split_words("pcs resource op a", ["3", "8", "2", "A"]) ) def test_refuse_when_lengths_are_too_big(self): self.assertRaises( EnvironmentError, lambda: _split_words("pcs resource op a", ["3", "8", "2", "10"]) ) def test_refuse_when_separator_doesnot_match(self): self.assertRaises( EnvironmentError, lambda: _split_words("pc sresource op a", ["3", "8", "2", "1"]) ) def test_refuse_when_lengths_are_too_small(self): self.assertRaises( EnvironmentError, lambda: _split_words("pcs resource op a ", ["3", "8", "2", "1"]) ) pcs-0.9.155/pcs/cli/common/test/test_console_report.py000066400000000000000000000163061301012375000227270ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.common.console_report import( indent, CODE_TO_MESSAGE_BUILDER_MAP, format_optional, ) from pcs.common import report_codes as codes class IndentTest(TestCase): def test_indent_list_of_lines(self): self.assertEqual( indent([ "first", "second" ]), [ " first", " second" ] ) class NameBuildTest(TestCase): """ Mixin for the testing of message building. """ code = None def assert_message_from_info(self, message, info): build = CODE_TO_MESSAGE_BUILDER_MAP[self.code] self.assertEqual(message, build(info)) class BuildInvalidOptionMessageTest(NameBuildTest): code = codes.INVALID_OPTION def test_build_message_with_type(self): self.assert_message_from_info( "invalid TYPE option 'NAME', allowed options are: FIRST, SECOND", { "option_name": "NAME", "option_type": "TYPE", "allowed": sorted(["FIRST", "SECOND"]), } ) def test_build_message_without_type(self): self.assert_message_from_info( "invalid option 'NAME', allowed options are: FIRST, SECOND", { "option_name": "NAME", "option_type": "", "allowed": sorted(["FIRST", "SECOND"]), } ) class BuildInvalidOptionValueMessageTest(NameBuildTest): code = codes.INVALID_OPTION_VALUE def test_build_message_with_multiple_allowed_values(self): self.assert_message_from_info( "'VALUE' is not a valid NAME value, use FIRST, SECOND", { "option_name": "NAME", "option_value": "VALUE", "allowed_values": sorted(["FIRST", "SECOND"]), } ) def test_build_message_with_hint(self): self.assert_message_from_info( "'VALUE' is not a valid NAME value, use some hint", { "option_name": "NAME", "option_value": "VALUE", "allowed_values": "some hint", } ) class BuildServiceStartErrorTest(NameBuildTest): code = codes.SERVICE_START_ERROR def test_build_message_with_instance_and_node(self): self.assert_message_from_info( "NODE: Unable to start SERVICE@INSTANCE: REASON", { "service": "SERVICE", "reason": "REASON", "node": "NODE", "instance": "INSTANCE", } ) def test_build_message_with_instance_only(self): self.assert_message_from_info( "Unable to start SERVICE@INSTANCE: REASON", { "service": "SERVICE", "reason": "REASON", "node": "", "instance": "INSTANCE", } ) def test_build_message_with_node_only(self): self.assert_message_from_info( "NODE: Unable to start SERVICE: REASON", { "service": "SERVICE", "reason": "REASON", "node": "NODE", "instance": "", } ) def test_build_message_without_node_and_instance(self): self.assert_message_from_info( "Unable to start SERVICE: REASON", { "service": "SERVICE", "reason": "REASON", "node": "", "instance": "", } ) class BuildInvalidIdTest(NameBuildTest): code = codes.INVALID_ID def test_build_message_with_first_char_invalid(self): self.assert_message_from_info( ( "invalid ID_DESCRIPTION 'ID', 'INVALID_CHARACTER' is not a" " valid first character for a ID_DESCRIPTION" ), { "id_description": "ID_DESCRIPTION", "id": "ID", "invalid_character": "INVALID_CHARACTER", "is_first_char": True, } ) def test_build_message_with_non_first_char_invalid(self): self.assert_message_from_info( ( "invalid ID_DESCRIPTION 'ID', 'INVALID_CHARACTER' is not a" " valid character for a ID_DESCRIPTION" ), { "id_description": "ID_DESCRIPTION", "id": "ID", "invalid_character": "INVALID_CHARACTER", "is_first_char": False, } ) class BuildRunExternalaStartedTest(NameBuildTest): code = codes.RUN_EXTERNAL_PROCESS_STARTED def test_build_message_with_stdin(self): self.assert_message_from_info( ( "Running: COMMAND\n" "--Debug Input Start--\n" "STDIN\n" "--Debug Input End--\n" ), { "command": "COMMAND", "stdin": "STDIN", } ) def test_build_message_without_stdin(self): self.assert_message_from_info( "Running: COMMAND\n", { "command": "COMMAND", "stdin": "", } ) class BuildNodeCommunicationStartedTest(NameBuildTest): code = codes.NODE_COMMUNICATION_STARTED def test_build_message_with_data(self): self.assert_message_from_info( ( "Sending HTTP Request to: TARGET\n" "--Debug Input Start--\n" "DATA\n" "--Debug Input End--\n" ), { "target": "TARGET", "data": "DATA", } ) def test_build_message_without_data(self): self.assert_message_from_info( "Sending HTTP Request to: TARGET\n", { "target": "TARGET", "data": "", } ) class FormatOptionalTest(TestCase): def test_info_key_is_falsy(self): self.assertEqual("", format_optional("", "{0}: ")) def test_info_key_is_not_falsy(self): self.assertEqual("A: ", format_optional("A", "{0}: ")) class AgentNameGuessedTest(NameBuildTest): code = codes.AGENT_NAME_GUESSED def test_build_message_with_data(self): self.assert_message_from_info( "Assumed agent name 'ocf:heratbeat:Delay' (deduced from 'Delay')", { "entered_name": "Delay", "guessed_name": "ocf:heratbeat:Delay", } ) class InvalidResourceAgentNameTest(NameBuildTest): code = codes.INVALID_RESOURCE_AGENT_NAME def test_build_message_with_data(self): self.assert_message_from_info( "Invalid resource agent name ':name'." " Use standard:provider:type or standard:type." " List of standards and providers can be obtained by using" " commands 'pcs resource standards' and" " 'pcs resource providers'" , { "name": ":name", } ) pcs-0.9.155/pcs/cli/common/test/test_lib_wrapper.py000066400000000000000000000043721301012375000222000ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.common.lib_wrapper import Library, bind from pcs.test.tools.pcs_unittest import mock from pcs.lib.errors import ReportItem from pcs.lib.errors import LibraryEnvError class LibraryWrapperTest(TestCase): def test_raises_for_bad_path(self): mock_middleware_factory = mock.MagicMock() lib = Library('env', mock_middleware_factory) self.assertRaises(Exception, lambda:lib.no_valid_library_part) @mock.patch('pcs.cli.common.lib_wrapper.constraint_order.create_with_set') @mock.patch('pcs.cli.common.lib_wrapper.cli_env_to_lib_env') def test_bind_to_library(self, mock_cli_env_to_lib_env, mock_order_set): lib_env = mock.MagicMock() lib_env.is_cib_live = True lib_env.is_corosync_conf_live = True mock_cli_env_to_lib_env.return_value = lib_env def dummy_middleware(next_in_line, env, *args, **kwargs): return next_in_line(env, *args, **kwargs) mock_middleware_factory = mock.MagicMock() mock_middleware_factory.cib = dummy_middleware mock_middleware_factory.corosync_conf_existing = dummy_middleware mock_env = mock.MagicMock() Library(mock_env, mock_middleware_factory).constraint_order.set( 'first', second="third" ) mock_order_set.assert_called_once_with(lib_env, "first", second="third") class BindTest(TestCase): @mock.patch("pcs.cli.common.lib_wrapper.process_library_reports") def test_report_unprocessed_library_env_errors(self, mock_process_report): report1 = ReportItem.error("OTHER ERROR", info={}) report2 = ReportItem.error("OTHER ERROR", info={}) report3 = ReportItem.error("OTHER ERROR", info={}) e = LibraryEnvError(report1, report2, report3) e.sign_processed(report2) mock_middleware = mock.Mock(side_effect=e) binded = bind( cli_env=None, run_with_middleware=mock_middleware, run_library_command=None ) self.assertRaises(SystemExit, lambda: binded(cli_env=None)) mock_process_report.assert_called_once_with([report1, report3]) pcs-0.9.155/pcs/cli/common/test/test_middleware.py000066400000000000000000000022551301012375000220050ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.common import middleware class MiddlewareBuildTest(TestCase): def test_run_middleware_correctly_chained(self): log = [] def command(lib, argv, modificators): log.append('command: {0}, {1}, {2}'.format(lib, argv, modificators)) def m1(next, lib, argv, modificators): log.append( 'm1 start: {0}, {1}, {2}'.format(lib, argv, modificators) ) next(lib, argv, modificators) log.append('m1 done') def m2(next, lib, argv, modificators): log.append( 'm2 start: {0}, {1}, {2}'.format(lib, argv, modificators) ) next(lib, argv, modificators) log.append('m2 done') run_with_middleware = middleware.build(m1, m2) run_with_middleware(command, "1", "2", "3") self.assertEqual(log, [ 'm1 start: 1, 2, 3', 'm2 start: 1, 2, 3', 'command: 1, 2, 3', 'm2 done', 'm1 done', ]) pcs-0.9.155/pcs/cli/common/test/test_parse_args.py000066400000000000000000000071741301012375000220230ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.common.parse_args import( split_list, prepare_options, group_by_keywords, ) from pcs.cli.common.errors import CmdLineInputError class PrepareOptionsTest(TestCase): def test_refuse_option_without_value(self): self.assertRaises( CmdLineInputError, lambda: prepare_options(['abc']) ) def test_prepare_option_dict_form_args(self): self.assertEqual({'a': 'b', 'c': 'd'}, prepare_options(['a=b', 'c=d'])) def test_prepare_option_dict_with_empty_value(self): self.assertEqual({'a': ''}, prepare_options(['a='])) def test_refuse_option_without_key(self): self.assertRaises( CmdLineInputError, lambda: prepare_options(['=a']) ) class SplitListTest(TestCase): def test_returns_list_with_original_when_separator_not_in_original(self): self.assertEqual([['a', 'b']], split_list(['a', 'b'], 'c')) def test_returns_splited_list(self): self.assertEqual( [['a', 'b'], ['c', 'd']], split_list(['a', 'b', '|', 'c', 'd'], '|') ) def test_behave_like_string_split_when_the_separator_edges(self): self.assertEqual( [[], ['a', 'b'], ['c', 'd'], []], split_list(['|','a', 'b', '|', 'c', 'd', "|"], '|') ) class SplitByKeywords(TestCase): def test_split_with_implicit_first_keyword(self): self.assertEqual( group_by_keywords( [0, "first", 1, 2, "second", 3], set(["first", "second"]), implicit_first_keyword="zero" ), { "zero": [0], "first": [1, 2], "second": [3], } ) def test_splict_without_implict_keyword(self): self.assertEqual( group_by_keywords( ["first", 1, 2, "second", 3], set(["first", "second"]), ), { "first": [1, 2], "second": [3], } ) def test_raises_when_args_do_not_start_with_keyword_nor_implicit(self): self.assertRaises(CmdLineInputError, lambda: group_by_keywords( [0, "first", 1, 2, "second", 3], set(["first", "second"]), )) def test_returns_dict_with_empty_lists_for_no_args(self): self.assertEqual( group_by_keywords( [], set(["first", "second"]) ), { "first": [], "second": [], } ) def test_returns_dict_with_empty_lists_for_no_args_implicit_case(self): self.assertEqual( group_by_keywords( [], set(["first", "second"]), implicit_first_keyword="zero", ), { "zero": [], "first": [], "second": [], } ) def test_allow_keywords_repeating(self): self.assertEqual( group_by_keywords( ["first", 1, 2, "second", 3, "first", 4], set(["first", "second"]), ), { "first": [1, 2, 4], "second": [3], } ) def test_can_disallow_keywords_repeating(self): self.assertRaises(CmdLineInputError, lambda: group_by_keywords( ["first", 1, 2, "second", 3, "first"], set(["first", "second"]), keyword_repeat_allowed=False, )) pcs-0.9.155/pcs/cli/common/test/test_reports.py000066400000000000000000000047331301012375000213710ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from collections import namedtuple from pcs.cli.common.reports import build_message_from_report ReportItem = namedtuple("ReportItem", "code info") class BuildMessageFromReportTest(TestCase): def test_returns_default_message_when_code_not_in_map(self): info = {"first": "FIRST"} self.assertEqual( "Unknown report: SOME info: {0}force text".format(str(info)) , build_message_from_report( {}, ReportItem("SOME", info), "force text" ) ) def test_complete_force_text(self): self.assertEqual( "Message force text is inside", build_message_from_report( { "SOME": "Message {force} is inside", }, ReportItem("SOME", {}), "force text" ) ) def test_deal_with_callable(self): self.assertEqual( "Info: MESSAGE", build_message_from_report( { "SOME": lambda info: "Info: {message}".format(**info), }, ReportItem("SOME", {"message": "MESSAGE"}), ) ) def test_append_force_when_needed_and_not_specified(self): self.assertEqual( "message force at the end", build_message_from_report( {"SOME": "message"}, ReportItem("SOME", {}), " force at the end", ) ) def test_returns_default_message_when_conflict_key_appear(self): info = {"message": "MESSAGE"} self.assertEqual( "Unknown report: SOME info: {0}".format(str(info)), build_message_from_report( { "SOME": lambda info: "Info: {message} {extra}".format( message="ANY", **info ), }, ReportItem("SOME", info), ) ) def test_returns_default_message_when_key_disappear(self): self.assertEqual( "Unknown report: SOME info: {}" , build_message_from_report( { "SOME": lambda info: "Info: {message}".format(**info), }, ReportItem("SOME", {}), ) ) pcs-0.9.155/pcs/cli/constraint/000077500000000000000000000000001301012375000161705ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint/__init__.py000066400000000000000000000000001301012375000202670ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint/command.py000066400000000000000000000050611301012375000201620ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.cli.constraint import parse_args, console_report from pcs.cli.common.console_report import indent def create_with_set(create_with_set_library_call, argv, modificators): """ callable create_with_set_library_call create constraint with set list argv part of comandline args see usage for "constraint (colocation|resource|ticket) set" dict like object modificators can contain "force" allows resource in clone/master and constraint duplicity "autocorrect" allows correct resource to its clone/master parent """ resource_set_list, constraint_options = parse_args.prepare_set_args(argv) create_with_set_library_call( resource_set_list, constraint_options, can_repair_to_clone=modificators["autocorrect"], resource_in_clone_alowed=modificators["force"], duplication_alowed=modificators["force"], ) def show_constraints_with_set(constraint_list, show_detail, indent_step=2): """ return list of console lines with info about constraints list of dict constraint_list see constraint in pcs/lib/exchange_formats.md bool with_id have to show id with options int indent_step is count of spaces for indenting """ return ["Resource Sets:"] + indent( [ console_report.constraint_with_sets(constraint, with_id=show_detail) for constraint in constraint_list ], indent_step=indent_step ) def show(caption, load_constraints, format_options, modificators): """ load constraints and return console lines list with info about constraints string caption for example "Ticket Constraints:" callable load_constraints which returns desired constraints as dictionary like {"plain": [], "with_resource_sets": []} callable format_options takes dict of options and show_detail flag (bool) and returns string with constraint formated for commandline modificators dict like object with command modificators """ show_detail = modificators["full"] constraints = load_constraints() line_list = [caption] line_list.extend([ " " + format_options(constraint_options_dict, show_detail) for constraint_options_dict in constraints["plain"] ]) if constraints["with_resource_sets"]: line_list.extend( indent(show_constraints_with_set( constraints["with_resource_sets"], show_detail )) ) return line_list pcs-0.9.155/pcs/cli/constraint/console_report.py000066400000000000000000000030751301012375000216040ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) def constraint_plain(constraint_type, constraint_info, with_id=False): return constraint_type + " ".join( prepare_options(constraint_info["options"], with_id) ) def resource_sets(set_list, with_id=True): """ list of dict set_list see resource set in pcs/lib/exchange_formats.md """ report = [] for resource_set in set_list: report.extend( ["set"] + resource_set["ids"] + options(resource_set["options"]) ) if with_id: report.append(id_from_options(resource_set["options"])) return report def options(options_dict): return [ key+"="+value for key, value in sorted(options_dict.items()) if key != "id" ] def id_from_options(options_dict): return "(id:"+options_dict.get("id", "")+")" def constraint_with_sets(constraint_info, with_id=True): """ dict constraint_info see constraint in pcs/lib/exchange_formats.md bool with_id have to show id with options_dict """ options_dict = options(constraint_info["options"]) return " ".join( resource_sets(constraint_info["resource_sets"], with_id) + (["setoptions"] + options_dict if options_dict else []) + ([id_from_options(constraint_info["options"])] if with_id else []) ) def prepare_options(options_dict, with_id=True): return ( options(options_dict) + ([id_from_options(options_dict)] if with_id else []) ) pcs-0.9.155/pcs/cli/constraint/parse_args.py000066400000000000000000000024571301012375000207000ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.cli.common import parse_args from pcs.cli.common.errors import CmdLineInputError def prepare_resource_sets(cmdline_args): return [ { "ids": [id for id in args if "=" not in id], "options": parse_args.prepare_options( [opt for opt in args if "=" in opt] ), } for args in parse_args.split_list(cmdline_args, "set") ] def prepare_set_args(argv): if argv.count("setoptions") > 1: raise CmdLineInputError( "Keyword 'setoptions' may be mentioned at most once" ) resource_set_args, constraint_options_args = ( parse_args.split_list(argv, "setoptions") if "setoptions" in argv else (argv, []) ) if not resource_set_args: raise CmdLineInputError() resource_set_list = prepare_resource_sets(resource_set_args) if( not resource_set_list or not all(resource_set["ids"] for resource_set in resource_set_list) ): raise CmdLineInputError() constraint_options = {} if constraint_options_args: constraint_options = parse_args.prepare_options(constraint_options_args) return (resource_set_list, constraint_options) pcs-0.9.155/pcs/cli/constraint/test/000077500000000000000000000000001301012375000171475ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint/test/__init__.py000066400000000000000000000000001301012375000212460ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint/test/test_command.py000066400000000000000000000045421301012375000222030ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.constraint import command from pcs.test.tools.pcs_unittest import mock def fixture_constraint(): return { "resource_sets": [ {"ids": ["a", "b"], "options": {"c": "d", "e": "f"}}, {"ids": ["g", "h"], "options": {"i": "j", "k": "l"}}, ], "options": {"m": "n", "o":"p"} } def fixture_constraint_console(): return " set a b c=d e=f (id:) set g h i=j k=l (id:) setoptions m=n o=p (id:)" class ShowConstraintsWithSetTest(TestCase): def test_return_line_list(self): self.assertEqual( [ "Resource Sets:", " set a b c=d e=f set g h i=j k=l setoptions m=n o=p", ], command.show_constraints_with_set( [fixture_constraint()], show_detail=False ) ) def test_return_line_list_with_id(self): self.assertEqual( [ "Resource Sets:", fixture_constraint_console(), ], command.show_constraints_with_set( [fixture_constraint()], show_detail=True ) ) class ShowTest(TestCase): def test_show_only_caption_when_no_constraint_loaded(self): self.assertEqual(["caption"], command.show( "caption", load_constraints=lambda: {"plain": [], "with_resource_sets": []}, format_options=lambda: None, modificators={"full": False} )) def test_show_constraints_full(self): load_constraints = mock.Mock() load_constraints.return_value = { "plain": [{"options": {"id": "plain_id"}}], "with_resource_sets": [fixture_constraint()] } format_options = mock.Mock() format_options.return_value = "plain constraint listing" self.assertEqual( [ "caption", " plain constraint listing", " Resource Sets:", " "+fixture_constraint_console(), ], command.show( "caption", load_constraints, format_options, {"full": True} ) ) pcs-0.9.155/pcs/cli/constraint/test/test_console_report.py000066400000000000000000000045201301012375000236160ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.constraint import console_report class OptionsTest(TestCase): def test_get_console_options_from_lib_options(self): self.assertEqual( ["a=b", "c=d"], console_report.options({"c": "d", "a": "b", "id":"some_id"}) ) class IdFromOptionsTest(TestCase): def test_get_id_from_options(self): self.assertEqual( '(id:some_id)', console_report.id_from_options({"c": "d", "a": "b", "id":"some_id"}) ) class PrepareOptionsTest(TestCase): def test_prepare_options_with_id(self): self.assertEqual( ["a=b", "c=d", '(id:some_id)'], console_report.prepare_options({"c": "d", "a": "b", "id":"some_id"}) ) def test_prepare_options_without_id(self): self.assertEqual( ["a=b", "c=d"], console_report.prepare_options( {"c": "d", "a": "b", "id":"some_id"}, with_id=False ) ) class ResourceSetsTest(TestCase): def test_prepare_resource_sets_without_id(self): self.assertEqual( ['set', 'a', 'b', 'c=d', 'e=f', 'set', 'g', 'h', 'i=j', 'k=l'], console_report.resource_sets( [ { "ids": ["a", "b"], "options": {"c": "d", "e": "f", "id": "some_id"}, }, { "ids": ["g", "h"], "options": {"i": "j", "k": "l", "id": "some_id_2"}, }, ], with_id=False ) ) def test_prepare_resource_sets_with_id(self): self.assertEqual( [ 'set', 'a', 'b', 'c=d', 'e=f', '(id:some_id)', 'set', 'g', 'h', 'i=j', 'k=l', '(id:some_id_2)' ], console_report.resource_sets([ { "ids": ["a", "b"], "options": {"c": "d", "e": "f", "id": "some_id"}, }, { "ids": ["g", "h"], "options": {"i": "j", "k": "l", "id": "some_id_2"}, }, ]) ) pcs-0.9.155/pcs/cli/constraint/test/test_parse_args.py000066400000000000000000000056321301012375000227140ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.common.errors import CmdLineInputError from pcs.cli.constraint.parse_args import prepare_set_args, prepare_resource_sets from pcs.test.tools.pcs_unittest import mock @mock.patch("pcs.cli.common.parse_args.prepare_options") class PrepareResourceSetsTest(TestCase): def test_prepare_resource_sets(self, options): opts = [{"id": "1"}, {"id": "2", "sequential": "true"}] options.side_effect = opts self.assertEqual( [ {"ids": ["resA", "resB"], "options":opts[0]}, {"ids": ["resC"], "options": opts[1]}, ], prepare_resource_sets([ "resA", "resB", "id=resource-set-1", "set", "resC", "id=resource-set-2", "sequential=true", ]) ) def test_has_no_responsibility_to_assess_the_content(self, options): options.return_value = {} self.assertEqual([{"ids":[], "options":{}}], prepare_resource_sets([])) @mock.patch("pcs.cli.common.parse_args.prepare_options") @mock.patch("pcs.cli.constraint.parse_args.prepare_resource_sets") class PrepareSetArgvTest(TestCase): def test_return_tuple_of_given_resource_set_list_and_options( self, res_sets, options ): res_sets.return_value = [{"ids": "A"}] options.return_value = 'O' self.assertEqual( ([{"ids": "A"}], "O"), prepare_set_args(['A', 'b=c', "setoptions", "d=e"]) ) def test_right_distribute_full_args(self, res_sets, options): prepare_set_args(['A', 'b=c', "setoptions", "d=e"]) res_sets.assert_called_once_with(['A', 'b=c']) options.assert_called_once_with(["d=e"]) def test_right_distribute_args_without_options(self, res_sets, options): prepare_set_args(['A', 'b=c']) res_sets.assert_called_once_with(['A', 'b=c']) options.assert_not_called() def test_right_distribute_args_with_empty_options(self, res_sets, options): prepare_set_args(['A', 'b=c', 'setoptions']) res_sets.assert_called_once_with(['A', 'b=c']) options.assert_not_called() def test_raises_when_no_set_specified(self, res_sets, options): self.assertRaises(CmdLineInputError, lambda: prepare_set_args([])) res_sets.assert_not_called() def test_raises_when_no_resource_in_set(self, res_sets, options): res_sets.return_value = [{"ids": [], "options": {"b": "c"}}] self.assertRaises(CmdLineInputError, lambda: prepare_set_args(["b=c"])) res_sets.assert_called_once_with(["b=c"]) def test_raises_when_setoption_more_than_once(self, res_sets, options): self.assertRaises(CmdLineInputError, lambda: prepare_set_args( ['A', 'b=c', 'setoptions', "c=d", "setoptions", "e=f"] )) pcs-0.9.155/pcs/cli/constraint_all/000077500000000000000000000000001301012375000170205ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_all/__init__.py000066400000000000000000000000001301012375000211170ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_all/console_report.py000066400000000000000000000044071301012375000224340ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.cli.constraint.console_report import ( constraint_plain as constraint_plain_default, constraint_with_sets, ) from pcs.cli.constraint_colocation.console_report import ( constraint_plain as colocation_plain ) from pcs.cli.constraint_order.console_report import ( constraint_plain as order_plain ) from pcs.cli.constraint_ticket.console_report import ( constraint_plain as ticket_plain ) from pcs.common import report_codes as codes def constraint(constraint_type, constraint_info, with_id=True): """ dict constraint_info see constraint in pcs/lib/exchange_formats.md bool with_id have to show id with options_dict """ if "resource_sets" in constraint_info: return constraint_with_sets(constraint_info, with_id) return constraint_plain(constraint_type, constraint_info, with_id) def constraint_plain(constraint_type, options_dict, with_id=False): """return console shape for any constraint_type of plain constraint""" type_report_map = { "rsc_colocation": colocation_plain, "rsc_order": order_plain, "rsc_ticket": ticket_plain, } if constraint_type not in type_report_map: return constraint_plain_default(constraint_type, options_dict, with_id) return type_report_map[constraint_type](options_dict, with_id) #Each value (callable taking report_item.info) returns string template. #Optionaly the template can contain placehodler {force} for next processing. #Placeholder {force} will be appended if is necessary and if is not presset CODE_TO_MESSAGE_BUILDER_MAP = { codes.DUPLICATE_CONSTRAINTS_EXIST: lambda info: "duplicate constraint already exists{force}\n" + "\n".join([ " " + constraint(info["constraint_type"], constraint_info) for constraint_info in info["constraint_info_list"] ]) , codes.RESOURCE_FOR_CONSTRAINT_IS_MULTIINSTANCE: lambda info: ( "{resource_id} is a {mode} resource, you should use the" " {parent_type} id: {parent_id} when adding constraints" ).format( mode="master/slave" if info["parent_type"] == "master" else "clone", **info ) , } pcs-0.9.155/pcs/cli/constraint_all/test/000077500000000000000000000000001301012375000177775ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_all/test/__init__.py000066400000000000000000000000001301012375000220760ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_all/test/test_console_report.py000066400000000000000000000075151301012375000244550ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.test.tools.pcs_unittest import mock from pcs.cli.constraint_all import console_report from pcs.common import report_codes as codes class ConstraintTest(TestCase): @mock.patch("pcs.cli.constraint_all.console_report.constraint_plain") def test_can_display_plain_constraint(self, mock_constraint_plain): mock_constraint_plain.return_value = "plain" self.assertEqual( 'plain', console_report.constraint( "rsc_ticket", "constraint_in_library_representation" ) ) mock_constraint_plain.assert_called_once_with( "rsc_ticket", "constraint_in_library_representation", True ) @mock.patch("pcs.cli.constraint_all.console_report.constraint_with_sets") def test_can_display_constraint_with_set(self, mock_constraint_with_sets): mock_constraint_with_sets.return_value = "with_set" self.assertEqual( 'with_set', console_report.constraint( "rsc_ticket", {"resource_sets": "some_resource_sets", "options": {"a": "b"}}, with_id=False ) ) mock_constraint_with_sets.assert_called_once_with( {"resource_sets": "some_resource_sets", "options": {"a": "b"}}, False ) class ConstraintPlainTest(TestCase): @mock.patch("pcs.cli.constraint_all.console_report.colocation_plain") def test_choose_right_reporter(self, mock_colocation_plain): mock_colocation_plain.return_value = "some constraint formated" self.assertEqual( "some constraint formated", console_report.constraint_plain( "rsc_colocation", "constraint_in_library_representation", with_id=True ) ) mock_colocation_plain.assert_called_once_with( "constraint_in_library_representation", True ) class DuplicateConstraintsReportTest(TestCase): def setUp(self): self.build = console_report.CODE_TO_MESSAGE_BUILDER_MAP[ codes.DUPLICATE_CONSTRAINTS_EXIST ] @mock.patch("pcs.cli.constraint_all.console_report.constraint") def test_translate_from_report_info(self, mock_constraint): mock_constraint.return_value = "constraint info" self.assertEqual( "\n".join([ "duplicate constraint already exists{force}", " constraint info" ]), self.build({ "constraint_info_list": [{"options": {"a": "b"}}], "constraint_type": "rsc_some" }) ) class ResourceForConstraintIsMultiinstanceTest(TestCase): def setUp(self): self.build = console_report.CODE_TO_MESSAGE_BUILDER_MAP[ codes.RESOURCE_FOR_CONSTRAINT_IS_MULTIINSTANCE ] def test_build_message_for_master(self): self.assertEqual( "RESOURCE_PRIMITIVE is a master/slave resource, you should use the" " master id: RESOURCE_MASTER when adding constraints" , self.build({ "resource_id": "RESOURCE_PRIMITIVE", "parent_type": "master", "parent_id": "RESOURCE_MASTER" }) ) def test_build_message_for_clone(self): self.assertEqual( "RESOURCE_PRIMITIVE is a clone resource, you should use the" " clone id: RESOURCE_CLONE when adding constraints" , self.build({ "resource_id": "RESOURCE_PRIMITIVE", "parent_type": "clone", "parent_id": "RESOURCE_CLONE" }) ) pcs-0.9.155/pcs/cli/constraint_colocation/000077500000000000000000000000001301012375000204025ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_colocation/__init__.py000066400000000000000000000000001301012375000225010ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_colocation/command.py000066400000000000000000000021331301012375000223710ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.cli.constraint import command from pcs.cli.constraint_colocation import console_report def create_with_set(lib, argv, modificators): """ create colocation constraint with resource set object lib exposes library list argv see usage for "constraint colocation set" dict like object modificators can contain "force" allows resource in clone/master and constraint duplicity "autocorrect" allows correct resource to its clone/master parent """ command.create_with_set( lib.constraint_colocation.set, argv, modificators, ) def show(lib, argv, modificators): """ show all colocation constraints object lib exposes library list argv see usage for "constraint colocation show" dict like object modificators can contain "full" """ print("\n".join(command.show( "Colocation Constraints:", lib.constraint_colocation.show, console_report.constraint_plain, modificators, ))) pcs-0.9.155/pcs/cli/constraint_colocation/console_report.py000066400000000000000000000016511301012375000240140ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) def constraint_plain(constraint_info, with_id=False): """ dict constraint_info see constraint in pcs/lib/exchange_formats.md bool with_id have to show id with options_dict """ options_dict = constraint_info["options"] co_resource1 = options_dict.get("rsc", "") co_resource2 = options_dict.get("with-rsc", "") co_id = options_dict.get("id", "") co_score = options_dict.get("score", "") score_text = "(score:" + co_score + ")" console_option_list = [ "(%s:%s)" % (option[0], option[1]) for option in sorted(options_dict.items()) if option[0] not in ("rsc", "with-rsc", "id", "score") ] if with_id: console_option_list.append("(id:%s)" % co_id) return " ".join( [co_resource1, "with", co_resource2, score_text] + console_option_list ) pcs-0.9.155/pcs/cli/constraint_order/000077500000000000000000000000001301012375000173635ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_order/__init__.py000066400000000000000000000000001301012375000214620ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_order/command.py000066400000000000000000000020761301012375000213600ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.cli.constraint import command from pcs.cli.constraint_order import console_report def create_with_set(lib, argv, modificators): """ create order constraint with resource set object lib exposes library list argv see usage for "constraint colocation set" dict like object modificators can contain "force" allows resource in clone/master and constraint duplicity "autocorrect" allows correct resource to its clone/master parent """ command.create_with_set( lib.constraint_order.set, argv, modificators ) def show(lib, argv, modificators): """ show all order constraints object lib exposes library list argv see usage for "constraint colocation show" dict like object modificators can contain "full" """ print("\n".join(command.show( "Ordering Constraints:", lib.constraint_order.show, console_report.constraint_plain, modificators, ))) pcs-0.9.155/pcs/cli/constraint_order/console_report.py000066400000000000000000000032521301012375000227740ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.lib.pacemaker_values import is_true def constraint_plain(constraint_info, with_id=False): """ dict constraint_info see constraint in pcs/lib/exchange_formats.md bool with_id have to show id with options_dict """ options = constraint_info["options"] oc_resource1 = options.get("first", "") oc_resource2 = options.get("then", "") first_action = options.get("first-action", "") then_action = options.get("then-action", "") oc_id = options.get("id", "") oc_score = options.get("score", "") oc_kind = options.get("kind", "") oc_sym = "" oc_id_out = "" oc_options = "" if ( "symmetrical" in options and not is_true(options.get("symmetrical", "false")) ): oc_sym = "(non-symmetrical)" if oc_kind != "": score_text = "(kind:" + oc_kind + ")" elif oc_kind == "" and oc_score == "": score_text = "(kind:Mandatory)" else: score_text = "(score:" + oc_score + ")" if with_id: oc_id_out = "(id:"+oc_id+")" already_processed_options = ( "first", "then", "first-action", "then-action", "id", "score", "kind", "symmetrical" ) oc_options = " ".join([ "{0}={1}".format(name, value) for name, value in options.items() if name not in already_processed_options ]) if oc_options: oc_options = "(Options: " + oc_options + ")" return " ".join([arg for arg in [ first_action, oc_resource1, "then", then_action, oc_resource2, score_text, oc_sym, oc_options, oc_id_out ] if arg]) pcs-0.9.155/pcs/cli/constraint_ticket/000077500000000000000000000000001301012375000175335ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_ticket/__init__.py000066400000000000000000000000001301012375000216320ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_ticket/command.py000066400000000000000000000045311301012375000215260ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.cli.common.errors import CmdLineInputError from pcs.cli.constraint import command from pcs.cli.constraint_ticket import parse_args, console_report from pcs.cli.common.console_report import error def create_with_set(lib, argv, modificators): """ create ticket constraint with resource set object lib exposes library list argv see usage for "constraint colocation set" dict like object modificators can contain "force" allows resource in clone/master and constraint duplicity "autocorrect" allows correct resource to its clone/master parent """ command.create_with_set( lib.constraint_ticket.set, argv, modificators, ) def add(lib, argv, modificators): """ create ticket constraint object lib exposes library list argv see usage for "constraint colocation add" dict like object modificators can contain "force" allows resource in clone/master and constraint duplicity "autocorrect" allows correct resource to its clone/master parent """ ticket, resource_id, resource_role, options = parse_args.parse_add(argv) if "rsc-role" in options: raise CmdLineInputError( "Resource role must not be specified among options" +", specify it before resource id" ) if resource_role: options["rsc-role"] = resource_role lib.constraint_ticket.add( ticket, resource_id, options, autocorrection_allowed=modificators["autocorrect"], resource_in_clone_alowed=modificators["force"], duplication_alowed=modificators["force"], ) def remove(lib, argv, modificators): if len(argv) != 2: raise CmdLineInputError() ticket, resource_id = argv if not lib.constraint_ticket.remove(ticket, resource_id): raise error("no matching ticket constraint found") def show(lib, argv, modificators): """ show all ticket constraints object lib exposes library list argv see usage for "constraint colocation show" dict like object modificators can contain "full" """ print("\n".join(command.show( "Ticket Constraints:", lib.constraint_ticket.show, console_report.constraint_plain, modificators, ))) pcs-0.9.155/pcs/cli/constraint_ticket/console_report.py000066400000000000000000000013321301012375000231410ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.cli.constraint.console_report import prepare_options def constraint_plain(constraint_info, with_id=False): """ dict constraint_info see constraint in pcs/lib/exchange_formats.md bool with_id have to show id with options_dict """ options = constraint_info["options"] role = options.get("rsc-role", "") role_prefix = "{0} ".format(role) if role else "" return role_prefix + " ".join([options.get("rsc", "")] + prepare_options( dict( (name, value) for name, value in options.items() if name not in ["rsc-role", "rsc"] ), with_id )) pcs-0.9.155/pcs/cli/constraint_ticket/parse_args.py000066400000000000000000000021461301012375000222360ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.cli.common import parse_args from pcs.cli.common.errors import CmdLineInputError def separate_tail_option_candidates(arg_list): for i, arg in enumerate(arg_list): if "=" in arg: return arg_list[:i], arg_list[i:] return arg_list, [] def parse_add(arg_list): info, option_candidates = separate_tail_option_candidates(arg_list) if not info: raise CmdLineInputError("Ticket not specified") ticket, resource_specification = info[0], info[1:] if len(resource_specification) not in (1, 2): raise CmdLineInputError( "invalid resource specification: '{0}'" .format(" ".join(resource_specification)) ) if len(resource_specification) == 2: resource_role, resource_id = resource_specification else: resource_role = "" resource_id = resource_specification[0] return ( ticket, resource_id, resource_role, parse_args.prepare_options(option_candidates) ) pcs-0.9.155/pcs/cli/constraint_ticket/test/000077500000000000000000000000001301012375000205125ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_ticket/test/__init__.py000066400000000000000000000000001301012375000226110ustar00rootroot00000000000000pcs-0.9.155/pcs/cli/constraint_ticket/test/test_command.py000066400000000000000000000061411301012375000235430ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.test.tools.pcs_unittest import mock from pcs.cli.common.errors import CmdLineInputError from pcs.cli.constraint_ticket import command class AddTest(TestCase): @mock.patch("pcs.cli.constraint_ticket.command.parse_args.parse_add") def test_call_library_with_correct_attrs(self, mock_parse_add): mock_parse_add.return_value = ( "ticket", "resource_id", "", {"loss-policy": "fence"} ) lib = mock.MagicMock() lib.constraint_ticket = mock.MagicMock() lib.constraint_ticket.add = mock.MagicMock() command.add(lib, ["argv"], {"force": True, "autocorrect": True}) mock_parse_add.assert_called_once_with(["argv"]) lib.constraint_ticket.add.assert_called_once_with( "ticket", "resource_id", {"loss-policy": "fence"}, autocorrection_allowed=True, resource_in_clone_alowed=True, duplication_alowed=True, ) @mock.patch("pcs.cli.constraint_ticket.command.parse_args.parse_add") def test_refuse_resource_role_in_options(self, mock_parse_add): mock_parse_add.return_value = ( "ticket", "resource_id", "resource_role", {"rsc-role": "master"} ) lib = None self.assertRaises( CmdLineInputError, lambda: command.add( lib, ["argv"], {"force": True, "autocorrect": True}, ) ) @mock.patch("pcs.cli.constraint_ticket.command.parse_args.parse_add") def test_put_resource_role_to_options_for_library(self, mock_parse_add): mock_parse_add.return_value = ( "ticket", "resource_id", "resource_role", {"loss-policy": "fence"} ) lib = mock.MagicMock() lib.constraint_ticket = mock.MagicMock() lib.constraint_ticket.add = mock.MagicMock() command.add(lib, ["argv"], {"force": True, "autocorrect": True}) mock_parse_add.assert_called_once_with(["argv"]) lib.constraint_ticket.add.assert_called_once_with( "ticket", "resource_id", {"loss-policy": "fence", "rsc-role": "resource_role"}, autocorrection_allowed=True, resource_in_clone_alowed=True, duplication_alowed=True, ) class RemoveTest(TestCase): def test_refuse_args_count(self): self.assertRaises(CmdLineInputError, lambda: command.remove( mock.MagicMock(), ["TICKET"], {}, )) self.assertRaises(CmdLineInputError, lambda: command.remove( mock.MagicMock(), ["TICKET", "RESOURCE", "SOMETHING_ELSE"], {}, )) def test_call_library_remove_with_correct_attrs(self): lib = mock.MagicMock( constraint_ticket=mock.MagicMock(remove=mock.Mock()) ) command.remove(lib, ["TICKET", "RESOURCE"], {}) lib.constraint_ticket.remove.assert_called_once_with( "TICKET", "RESOURCE", ) pcs-0.9.155/pcs/cli/constraint_ticket/test/test_console_report.py000066400000000000000000000016721301012375000251660ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.constraint_ticket import console_report class ConstraintPlainTest(TestCase): def test_prepare_report(self): self.assertEqual( "Master resourceA (id:some_id)", console_report.constraint_plain( {"options": { "rsc-role": "Master", "rsc": "resourceA", "id": "some_id" }}, with_id=True ) ) def test_prepare_report_without_role(self): self.assertEqual( "resourceA (id:some_id)", console_report.constraint_plain( {"options": { "rsc": "resourceA", "id": "some_id" }}, with_id=True ) ) pcs-0.9.155/pcs/cli/constraint_ticket/test/test_parse_args.py000066400000000000000000000046711301012375000242610ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.cli.constraint_ticket import parse_args from pcs.cli.common.errors import CmdLineInputError class ParseAddTest(TestCase): def test_parse_add_args(self): self.assertEqual( parse_args.parse_add( ["T", "resource1", "ticket=T", "loss-policy=fence"] ), ( "T", "resource1", "", { "ticket": "T", "loss-policy": "fence", } ) ) def test_parse_add_args_with_resource_role(self): self.assertEqual( parse_args.parse_add( ["T", "master", "resource1", "ticket=T", "loss-policy=fence"] ), ( "T", "resource1", "master", { "ticket": "T", "loss-policy": "fence", } ) ) def test_raises_when_invalid_resource_specification(self): self.assertRaises( CmdLineInputError, lambda: parse_args.parse_add( ["T", "master", "resource1", "something_else"] ) ) def test_raises_when_ticket_and_resource_not_specified(self): self.assertRaises( CmdLineInputError, lambda: parse_args.parse_add( ["loss-policy=fence"] ) ) def test_raises_when_resource_not_specified(self): self.assertRaises( CmdLineInputError, lambda: parse_args.parse_add( ["T", "loss-policy=fence"] ) ) class SeparateTailOptionCandidatesTest(TestCase): def test_separate_when_both_parts_there(self): self.assertEqual( (["a", "b"], ["c=d", "e=f"]), parse_args.separate_tail_option_candidates(["a", "b", "c=d", "e=f"]) ) def test_returns_empty_head_when_options_there_only(self): self.assertEqual( ([], ["c=d", "e=f"]), parse_args.separate_tail_option_candidates(["c=d", "e=f"]) ) def test_returns_empty_tail_when_no_options_there(self): self.assertEqual( (["a", "b"], []), parse_args.separate_tail_option_candidates(["a", "b"]) ) pcs-0.9.155/pcs/cluster.py000066400000000000000000002160621301012375000152770ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os import subprocess import re import sys import socket import tempfile import datetime import json import time import xml.dom.minidom try: # python2 from commands import getstatusoutput except ImportError: # python3 from subprocess import getstatusoutput from pcs import ( constraint, node, pcsd, quorum, resource, settings, status, stonith, usage, utils, ) from pcs.utils import parallel_for_nodes from pcs.common import report_codes from pcs.cli.common.reports import process_library_reports, build_report_message from pcs.lib import ( pacemaker as lib_pacemaker, sbd as lib_sbd, reports as lib_reports, ) from pcs.lib.booth import sync as booth_sync from pcs.lib.nodes_task import check_corosync_offline_on_nodes from pcs.lib.commands.quorum import _add_device_model_net from pcs.lib.corosync import ( config_parser as corosync_conf_utils, qdevice_net, ) from pcs.lib.corosync.config_facade import ConfigFacade as corosync_conf_facade from pcs.lib.errors import ( LibraryError, ReportItemSeverity, ) from pcs.lib.external import ( disable_service, is_systemctl, NodeCommunicationException, node_communicator_exception_to_report_item, ) from pcs.lib.node import NodeAddresses from pcs.lib.tools import environment_file_to_dict def cluster_cmd(argv): if len(argv) == 0: usage.cluster() exit(1) sub_cmd = argv.pop(0) if (sub_cmd == "help"): usage.cluster(argv) elif (sub_cmd == "setup"): if "--name" in utils.pcs_options: cluster_setup([utils.pcs_options["--name"]] + argv) else: utils.err( "A cluster name (--name ) is required to setup a cluster" ) elif (sub_cmd == "sync"): sync_nodes(utils.getNodesFromCorosyncConf(),utils.getCorosyncConf()) elif (sub_cmd == "status"): status.cluster_status(argv) elif (sub_cmd == "pcsd-status"): status.cluster_pcsd_status(argv) elif (sub_cmd == "certkey"): cluster_certkey(argv) elif (sub_cmd == "auth"): cluster_auth(argv) elif (sub_cmd == "token"): cluster_token(argv) elif (sub_cmd == "token-nodes"): cluster_token_nodes(argv) elif (sub_cmd == "start"): if "--all" in utils.pcs_options: start_cluster_all() else: start_cluster(argv) elif (sub_cmd == "stop"): if "--all" in utils.pcs_options: stop_cluster_all() else: stop_cluster(argv) elif (sub_cmd == "kill"): kill_cluster(argv) elif (sub_cmd == "standby"): node.node_standby(argv) elif (sub_cmd == "unstandby"): node.node_standby(argv, False) elif (sub_cmd == "enable"): if "--all" in utils.pcs_options: enable_cluster_all() else: enable_cluster(argv) elif (sub_cmd == "disable"): if "--all" in utils.pcs_options: disable_cluster_all() else: disable_cluster(argv) elif (sub_cmd == "remote-node"): cluster_remote_node(argv) elif (sub_cmd == "cib"): get_cib(argv) elif (sub_cmd == "cib-push"): cluster_push(argv) elif (sub_cmd == "cib-upgrade"): utils.cluster_upgrade() elif (sub_cmd == "edit"): cluster_edit(argv) elif (sub_cmd == "node"): cluster_node(argv) elif (sub_cmd == "localnode"): cluster_localnode(argv) elif (sub_cmd == "uidgid"): cluster_uidgid(argv) elif (sub_cmd == "corosync"): cluster_get_corosync_conf(argv) elif (sub_cmd == "reload"): cluster_reload(argv) elif (sub_cmd == "destroy"): cluster_destroy(argv) elif (sub_cmd == "verify"): cluster_verify(argv) elif (sub_cmd == "report"): cluster_report(argv) elif (sub_cmd == "quorum"): if argv and argv[0] == "unblock": quorum.quorum_unblock_cmd(argv[1:]) else: usage.cluster() sys.exit(1) else: usage.cluster() sys.exit(1) def sync_nodes(nodes,config): for node in nodes: utils.setCorosyncConfig(node,config) def cluster_auth(argv): if len(argv) == 0: auth_nodes(utils.getNodesFromCorosyncConf()) else: auth_nodes(argv) def cluster_token(argv): if len(argv) > 1: utils.err("Must specify only one node") elif len(argv) == 0: utils.err("Must specify a node to get authorization token from") node = argv[0] tokens = utils.readTokens() if node in tokens: print(tokens[node]) else: utils.err("No authorization token for: %s" % (node)) def cluster_token_nodes(argv): print("\n".join(sorted(utils.readTokens().keys()))) def auth_nodes(nodes): if "-u" in utils.pcs_options: username = utils.pcs_options["-u"] else: username = None if "-p" in utils.pcs_options: password = utils.pcs_options["-p"] else: password = None set_nodes = set(nodes) need_auth = "--force" in utils.pcs_options or (username or password) if not need_auth: for node in set_nodes: status = utils.checkAuthorization(node) if status[0] == 3: need_auth = True break mutually_authorized = False if status[0] == 0: try: auth_status = json.loads(status[1]) if auth_status["success"]: if set_nodes.issubset(set(auth_status["node_list"])): mutually_authorized = True except (ValueError, KeyError): pass if not mutually_authorized: need_auth = True break if need_auth: if username == None: username = utils.get_terminal_input('Username: ') if password == None: password = utils.get_terminal_password() utils.auth_nodes_do( set_nodes, username, password, '--force' in utils.pcs_options, '--local' in utils.pcs_options ) else: for node in set_nodes: print(node + ": Already authorized") def cluster_certkey(argv): return pcsd.pcsd_certkey(argv) def cluster_setup(argv): if len(argv) < 2: usage.cluster(["setup"]) sys.exit(1) is_rhel6 = utils.is_rhel6() cluster_name = argv[0] wait = False wait_timeout = None if "--start" in utils.pcs_options and "--wait" in utils.pcs_options: wait_timeout = utils.validate_wait_get_timeout(False) wait = True # get nodes' addresses udpu_rrp = False node_list = [] primary_addr_list = [] all_addr_list = [] for node in argv[1:]: addr_list = utils.parse_multiring_node(node) primary_addr_list.append(addr_list[0]) all_addr_list.append(addr_list[0]) node_options = { "ring0_addr": addr_list[0], } if addr_list[1]: udpu_rrp = True all_addr_list.append(addr_list[1]) node_options["ring1_addr"] = addr_list[1] node_list.append(node_options) # special case of ring1 address on cman if is_rhel6 and not udpu_rrp and "--addr1" in utils.pcs_options: for node in node_list: node["ring1_addr"] = utils.pcs_options["--addr1"] # verify addresses if udpu_rrp: for node_options in node_list: if "ring1_addr" not in node_options: utils.err( "if one node is configured for RRP, " + "all nodes must be configured for RRP" ) nodes_unresolvable = False for node_addr in all_addr_list: try: socket.getaddrinfo(node_addr, None) except socket.error: print("Warning: Unable to resolve hostname: {0}".format(node_addr)) nodes_unresolvable = True if nodes_unresolvable and "--force" not in utils.pcs_options: utils.err("Unable to resolve all hostnames, use --force to override") # parse, validate and complete options if is_rhel6: options, messages = cluster_setup_parse_options_cman( utils.pcs_options, "--force" in utils.pcs_options ) else: options, messages = cluster_setup_parse_options_corosync( utils.pcs_options, "--force" in utils.pcs_options ) if udpu_rrp and "rrp_mode" not in options["transport_options"]: options["transport_options"]["rrp_mode"] = "passive" process_library_reports(messages) # prepare config file if is_rhel6: config, messages = cluster_setup_create_cluster_conf( cluster_name, node_list, options["transport_options"], options["totem_options"] ) else: config, messages = cluster_setup_create_corosync_conf( cluster_name, node_list, options["transport_options"], options["totem_options"], options["quorum_options"] ) process_library_reports(messages) # setup on the local node if "--local" in utils.pcs_options: # Config path can be overriden by --corosync_conf or --cluster_conf # command line options. If it is overriden we do not touch any cluster # which may be set up on the local node. if is_rhel6: config_path = settings.cluster_conf_file else: config_path = settings.corosync_conf_file config_path_overriden = ( (is_rhel6 and "--cluster_conf" in utils.pcs_options) or (not is_rhel6 and "--corosync_conf" in utils.pcs_options) ) # verify and ensure no cluster is set up on the host if "--force" not in utils.pcs_options and os.path.exists(config_path): utils.err("{0} already exists, use --force to overwrite".format( config_path )) if not config_path_overriden: cib_path = os.path.join(settings.cib_dir, "cib.xml") if "--force" not in utils.pcs_options and os.path.exists(cib_path): utils.err("{0} already exists, use --force to overwrite".format( cib_path )) cluster_destroy([]) # set up the cluster utils.setCorosyncConf(config) if "--start" in utils.pcs_options: start_cluster([]) if "--enable" in utils.pcs_options: enable_cluster([]) if wait: wait_for_nodes_started([], wait_timeout) # setup on remote nodes else: # verify and ensure no cluster is set up on the nodes # checks that nodes are authenticated as well if "--force" not in utils.pcs_options: all_nodes_available = True for node in primary_addr_list: available, message = utils.canAddNodeToCluster(node) if not available: all_nodes_available = False utils.err("{0}: {1}".format(node, message), False) if not all_nodes_available: utils.err( "nodes availability check failed, use --force to override. " + "WARNING: This will destroy existing cluster on the nodes." ) print("Destroying cluster on nodes: {0}...".format( ", ".join(primary_addr_list) )) destroy_cluster(primary_addr_list) print() # send local cluster pcsd configs to the new nodes print("Sending cluster config files to the nodes...") pcsd_data = { "nodes": primary_addr_list, "force": True, "clear_local_cluster_permissions": True, } err_msgs = [] output, retval = utils.run_pcsdcli("send_local_configs", pcsd_data) if retval == 0 and output["status"] == "ok" and output["data"]: try: for node in primary_addr_list: node_response = output["data"][node] if node_response["status"] == "notauthorized": err_msgs.append( "Unable to authenticate to " + node + ", try running 'pcs cluster auth'" ) if node_response["status"] not in ["ok", "not_supported"]: err_msgs.append( "Unable to set pcsd configs on {0}".format(node) ) except: err_msgs.append("Unable to communicate with pcsd") else: err_msgs.append("Unable to set pcsd configs") for err_msg in err_msgs: print("Warning: {0}".format(err_msg)) # send the cluster config for node in primary_addr_list: utils.setCorosyncConfig(node, config) # start and enable the cluster if requested if "--start" in utils.pcs_options: print("\nStarting cluster on nodes: {0}...".format( ", ".join(primary_addr_list) )) start_cluster_nodes(primary_addr_list) if "--enable" in utils.pcs_options: enable_cluster(primary_addr_list) # sync certificates as the last step because it restarts pcsd print() pcsd.pcsd_sync_certs([], exit_after_error=False) if wait: print() wait_for_nodes_started(primary_addr_list, wait_timeout) def cluster_setup_parse_options_corosync(options, force=False): messages = [] parsed = { "transport_options": { "rings_options": [], }, "totem_options": {}, "quorum_options": {}, } severity = ReportItemSeverity.WARNING if force else ReportItemSeverity.ERROR forceable = None if force else report_codes.FORCE_OPTIONS transport = "udpu" if "--transport" in options: transport = options["--transport"] allowed_transport = ("udp", "udpu") if transport not in allowed_transport: messages.append(lib_reports.invalid_option_value( "transport", transport, allowed_transport, severity, forceable )) parsed["transport_options"]["transport"] = transport if transport == "udpu" and ("--addr0" in options or "--addr1" in options): messages.append(lib_reports.rrp_addresses_transport_mismatch()) rrpmode = None if "--rrpmode" in options or "--addr0" in options: rrpmode = "passive" if "--rrpmode" in options: rrpmode = options["--rrpmode"] allowed_rrpmode = ("passive", "active") if rrpmode not in allowed_rrpmode: messages.append(lib_reports.invalid_option_value( "RRP mode", rrpmode, allowed_rrpmode, severity, forceable )) if rrpmode == "active": messages.append(lib_reports.rrp_active_not_supported(force)) if rrpmode: parsed["transport_options"]["rrp_mode"] = rrpmode totem_options_names = { "--token": "token", "--token_coefficient": "token_coefficient", "--join": "join", "--consensus": "consensus", "--miss_count_const": "miss_count_const", "--fail_recv_const": "fail_recv_const", } for opt_name, parsed_name in totem_options_names.items(): if opt_name in options: parsed["totem_options"][parsed_name] = options[opt_name] if transport == "udp": interface_ids = [] if "--addr0" in options: interface_ids.append(0) if "--addr1" in options: interface_ids.append(1) for interface in interface_ids: ring_options = {} ring_options["addr"] = options["--addr{0}".format(interface)] if "--broadcast{0}".format(interface) in options: ring_options["broadcast"] = True else: if "--mcast{0}".format(interface) in options: mcastaddr = options["--mcast{0}".format(interface)] else: mcastaddr = "239.255.{0}.1".format(interface + 1) ring_options["mcastaddr"] = mcastaddr if "--mcastport{0}".format(interface) in options: mcastport = options["--mcastport{0}".format(interface)] else: mcastport = "5405" ring_options["mcastport"] = mcastport if "--ttl{0}".format(interface) in options: ring_options["ttl"] = options["--ttl{0}".format(interface)] parsed["transport_options"]["rings_options"].append(ring_options) if "--ipv6" in options: parsed["transport_options"]["ip_version"] = "ipv6" quorum_options_names = { "--wait_for_all": "wait_for_all", "--auto_tie_breaker": "auto_tie_breaker", "--last_man_standing": "last_man_standing", "--last_man_standing_window": "last_man_standing_window", } for opt_name, parsed_name in quorum_options_names.items(): if opt_name in options: parsed["quorum_options"][parsed_name] = options[opt_name] for opt_name in ( "--wait_for_all", "--auto_tie_breaker", "--last_man_standing" ): allowed_values = ("0", "1") if opt_name in options and options[opt_name] not in allowed_values: messages.append(lib_reports.invalid_option_value( opt_name, options[opt_name], allowed_values )) return parsed, messages def cluster_setup_parse_options_cman(options, force=False): messages = [] parsed = { "transport_options": { "rings_options": [], }, "totem_options": {}, } severity = ReportItemSeverity.WARNING if force else ReportItemSeverity.ERROR forceable = None if force else report_codes.FORCE_OPTIONS broadcast = ("--broadcast0" in options) or ("--broadcast1" in options) if broadcast: transport = "udpb" parsed["transport_options"]["broadcast"] = True ring_missing_broadcast = None if "--broadcast0" not in options: ring_missing_broadcast = "0" if "--broadcast1" not in options: ring_missing_broadcast = "1" if ring_missing_broadcast: messages.append(lib_reports.cman_broadcast_all_rings()) else: transport = "udp" if "--transport" in options: transport = options["--transport"] allowed_transport = ("udp", "udpu") if transport not in allowed_transport: messages.append(lib_reports.invalid_option_value( "transport", transport, allowed_transport, severity, forceable )) parsed["transport_options"]["transport"] = transport if transport == "udpu": messages.append(lib_reports.cman_udpu_restart_required()) if transport == "udpu" and ("--addr0" in options or "--addr1" in options): messages.append(lib_reports.rrp_addresses_transport_mismatch()) rrpmode = None if "--rrpmode" in options or "--addr0" in options: rrpmode = "passive" if "--rrpmode" in options: rrpmode = options["--rrpmode"] allowed_rrpmode = ("passive", "active") if rrpmode not in allowed_rrpmode: messages.append(lib_reports.invalid_option_value( "RRP mode", rrpmode, allowed_rrpmode, severity, forceable )) if rrpmode == "active": messages.append(lib_reports.rrp_active_not_supported(force)) if rrpmode: parsed["transport_options"]["rrp_mode"] = rrpmode totem_options_names = { "--token": "token", "--join": "join", "--consensus": "consensus", "--miss_count_const": "miss_count_const", "--fail_recv_const": "fail_recv_const", } for opt_name, parsed_name in totem_options_names.items(): if opt_name in options: parsed["totem_options"][parsed_name] = options[opt_name] if not broadcast: for interface in (0, 1): if "--addr{0}".format(interface) not in options: continue ring_options = {} if "--mcast{0}".format(interface) in options: mcastaddr = options["--mcast{0}".format(interface)] else: mcastaddr = "239.255.{0}.1".format(interface + 1) ring_options["mcastaddr"] = mcastaddr if "--mcastport{0}".format(interface) in options: ring_options["mcastport"] = options[ "--mcastport{0}".format(interface) ] if "--ttl{0}".format(interface) in options: ring_options["ttl"] = options["--ttl{0}".format(interface)] parsed["transport_options"]["rings_options"].append(ring_options) ignored_options_names = ( "--wait_for_all", "--auto_tie_breaker", "--last_man_standing", "--last_man_standing_window", "--token_coefficient", "--ipv6", ) for opt_name in ignored_options_names: if opt_name in options: messages.append(lib_reports.cman_ignored_option(opt_name)) return parsed, messages def cluster_setup_create_corosync_conf( cluster_name, node_list, transport_options, totem_options, quorum_options ): messages = [] corosync_conf = corosync_conf_utils.Section("") totem_section = corosync_conf_utils.Section("totem") nodelist_section = corosync_conf_utils.Section("nodelist") quorum_section = corosync_conf_utils.Section("quorum") logging_section = corosync_conf_utils.Section("logging") corosync_conf.add_section(totem_section) corosync_conf.add_section(nodelist_section) corosync_conf.add_section(quorum_section) corosync_conf.add_section(logging_section) totem_section.add_attribute("version", "2") totem_section.add_attribute("secauth", "off") totem_section.add_attribute("cluster_name", cluster_name) transport_options_names = ( "transport", "rrp_mode", "ip_version", ) for opt_name in transport_options_names: if opt_name in transport_options: totem_section.add_attribute(opt_name, transport_options[opt_name]) totem_options_names = ( "token", "token_coefficient", "join", "consensus", "miss_count_const", "fail_recv_const", ) for opt_name in totem_options_names: if opt_name in totem_options: totem_section.add_attribute(opt_name, totem_options[opt_name]) transport = None if "transport" in transport_options: transport = transport_options["transport"] if transport == "udp": if "rings_options" in transport_options: for ring_number, ring_options in enumerate( transport_options["rings_options"] ): interface_section = corosync_conf_utils.Section("interface") totem_section.add_section(interface_section) interface_section.add_attribute("ringnumber", ring_number) if "addr" in ring_options: interface_section.add_attribute( "bindnetaddr", ring_options["addr"] ) if "broadcast" in ring_options and ring_options["broadcast"]: interface_section.add_attribute("broadcast", "yes") else: for opt_name in ("mcastaddr", "mcastport", "ttl"): if opt_name in ring_options: interface_section.add_attribute( opt_name, ring_options[opt_name] ) for node_id, node_options in enumerate(node_list, 1): node_section = corosync_conf_utils.Section("node") nodelist_section.add_section(node_section) for opt_name in ("ring0_addr", "ring1_addr"): if opt_name in node_options: node_section.add_attribute(opt_name, node_options[opt_name]) node_section.add_attribute("nodeid", node_id) quorum_section.add_attribute("provider", "corosync_votequorum") quorum_options_names = ( "wait_for_all", "auto_tie_breaker", "last_man_standing", "last_man_standing_window", ) for opt_name in quorum_options_names: if opt_name in quorum_options: quorum_section.add_attribute(opt_name, quorum_options[opt_name]) auto_tie_breaker = ( "auto_tie_breaker" in quorum_options and quorum_options["auto_tie_breaker"] == "1" ) if len(node_list) == 2 and not auto_tie_breaker: quorum_section.add_attribute("two_node", "1") logging_section.add_attribute("to_logfile", "yes") logging_section.add_attribute("logfile", "/var/log/cluster/corosync.log") logging_section.add_attribute("to_syslog", "yes") return str(corosync_conf), messages def cluster_setup_create_cluster_conf( cluster_name, node_list, transport_options, totem_options ): broadcast = ( "broadcast" in transport_options and transport_options["broadcast"] ) commands = [] commands.append({ "cmd": ["-i", "--createcluster", cluster_name], "err": "error creating cluster: {0}".format(cluster_name), }) commands.append({ "cmd": ["-i", "--addfencedev", "pcmk-redirect", "agent=fence_pcmk"], "err": "error creating fence dev: {0}".format(cluster_name), }) cman_opts = [] if "transport" in transport_options: cman_opts.append("transport=" + transport_options["transport"]) cman_opts.append("broadcast=" + ("yes" if broadcast else "no")) if len(node_list) == 2: cman_opts.append("two_node=1") cman_opts.append("expected_votes=1") commands.append({ "cmd": ["--setcman"] + cman_opts, "err": "error setting cman options", }) for node_options in node_list: if "ring0_addr" in node_options: ring0_addr = node_options["ring0_addr"] commands.append({ "cmd": ["--addnode", ring0_addr], "err": "error adding node: {0}".format(ring0_addr), }) if "ring1_addr" in node_options: ring1_addr = node_options["ring1_addr"] commands.append({ "cmd": ["--addalt", ring0_addr, ring1_addr], "err": ( "error adding alternative address for node: {0}".format( ring0_addr ) ), }) commands.append({ "cmd": ["-i", "--addmethod", "pcmk-method", ring0_addr], "err": "error adding fence method: {0}".format(ring0_addr), }) commands.append({ "cmd": [ "-i", "--addfenceinst", "pcmk-redirect", ring0_addr, "pcmk-method", "port=" + ring0_addr ], "err": "error adding fence instance: {0}".format(ring0_addr), }) if not broadcast: if "rings_options" in transport_options: for ring_number, ring_options in enumerate( transport_options["rings_options"] ): mcast_options = [] if "mcastaddr" in ring_options: mcast_options.append(ring_options["mcastaddr"]) if "mcastport" in ring_options: mcast_options.append("port=" + ring_options["mcastport"]) if "ttl" in ring_options: mcast_options.append("ttl=" + ring_options["ttl"]) if ring_number == 0: cmd_name = "--setmulticast" else: cmd_name = "--setaltmulticast" commands.append({ "cmd": [cmd_name] + mcast_options, "err": "error adding ring{0} settings".format(ring_number), }) totem_options_names = ( "token", "join", "consensus", "miss_count_const", "fail_recv_const", ) totem_cmd_options = [] for opt_name in totem_options_names: if opt_name in totem_options: totem_cmd_options.append( "{0}={1}".format(opt_name, totem_options[opt_name]) ) if "rrp_mode" in transport_options: totem_cmd_options.append( "rrp_mode={0}".format(transport_options["rrp_mode"]) ) if totem_cmd_options: commands.append({ "cmd": ["--settotem"] + totem_cmd_options, "err": "error setting totem options", }) messages = [] conf_temp = tempfile.NamedTemporaryFile(mode="w+", suffix=".pcs") conf_path = conf_temp.name cmd_prefix = ["ccs", "-f", conf_path] for cmd_item in commands: output, retval = utils.run(cmd_prefix + cmd_item["cmd"]) if retval != 0: if output: messages.append(lib_reports.common_info(output)) messages.append(lib_reports.common_error(cmd_item["err"])) conf_temp.close() return "", messages conf_temp.seek(0) cluster_conf = conf_temp.read() conf_temp.close() return cluster_conf, messages def get_local_network(): args = ["/sbin/ip", "route"] p = subprocess.Popen(args, stdout=subprocess.PIPE) iproute_out = p.stdout.read() network_addr = re.search(r"^([0-9\.]+)", iproute_out) if network_addr: return network_addr.group(1) else: utils.err("unable to determine network address, is interface up?") def start_cluster(argv): wait = False wait_timeout = None if "--wait" in utils.pcs_options: wait_timeout = utils.validate_wait_get_timeout(False) wait = True if len(argv) > 0: start_cluster_nodes(argv) if wait: wait_for_nodes_started(argv, wait_timeout) return print("Starting Cluster...") service_list = [] if utils.is_cman_cluster(): # Verify that CMAN_QUORUM_TIMEOUT is set, if not, then we set it to 0 retval, output = getstatusoutput('source /etc/sysconfig/cman ; [ -z "$CMAN_QUORUM_TIMEOUT" ]') if retval == 0: with open("/etc/sysconfig/cman", "a") as cman_conf_file: cman_conf_file.write("\nCMAN_QUORUM_TIMEOUT=0\n") output, retval = utils.start_service("cman") if retval != 0: print(output) utils.err("unable to start cman") else: service_list.append("corosync") if utils.need_to_handle_qdevice_service(): service_list.append("corosync-qdevice") service_list.append("pacemaker") for service in service_list: output, retval = utils.start_service(service) if retval != 0: print(output) utils.err("unable to start {0}".format(service)) if wait: wait_for_nodes_started([], wait_timeout) def start_cluster_all(): wait = False wait_timeout = None if "--wait" in utils.pcs_options: wait_timeout = utils.validate_wait_get_timeout(False) wait = True all_nodes = utils.getNodesFromCorosyncConf() start_cluster_nodes(all_nodes) if wait: wait_for_nodes_started(all_nodes, wait_timeout) def start_cluster_nodes(nodes): node_errors = parallel_for_nodes(utils.startCluster, nodes, quiet=True) if node_errors: utils.err( "unable to start all nodes\n" + "\n".join(node_errors.values()) ) def is_node_fully_started(node_status): return ( "online" in node_status and "pending" in node_status and node_status["online"] and not node_status["pending"] ) def wait_for_local_node_started(stop_at, interval): try: while True: node_status = lib_pacemaker.get_local_node_status( utils.cmd_runner() ) if is_node_fully_started(node_status): return 0, "Started" if datetime.datetime.now() > stop_at: return 1, "Waiting timeout" time.sleep(interval) except LibraryError as e: return 1, "Unable to get node status: {0}".format( "\n".join([build_report_message(item) for item in e.args]) ) def wait_for_remote_node_started(node, stop_at, interval): while True: code, output = utils.getPacemakerNodeStatus(node) # HTTP error, permission denied or unable to auth # there is no point in trying again as it won't get magically fixed if code in [1, 3, 4]: return 1, output if code == 0: try: status = json.loads(output) if (is_node_fully_started(status)): return 0, "Started" except (ValueError, KeyError): # this won't get fixed either return 1, "Unable to get node status" if datetime.datetime.now() > stop_at: return 1, "Waiting timeout" time.sleep(interval) def wait_for_nodes_started(node_list, timeout=None): timeout = 60 * 15 if timeout is None else timeout interval = 2 stop_at = datetime.datetime.now() + datetime.timedelta(seconds=timeout) print("Waiting for node(s) to start...") if not node_list: code, output = wait_for_local_node_started(stop_at, interval) if code != 0: utils.err(output) else: print(output) else: node_errors = parallel_for_nodes( wait_for_remote_node_started, node_list, stop_at, interval ) if node_errors: utils.err("unable to verify all nodes have started") def stop_cluster_all(): stop_cluster_nodes(utils.getNodesFromCorosyncConf()) def stop_cluster_nodes(nodes): all_nodes = utils.getNodesFromCorosyncConf() unknown_nodes = set(nodes) - set(all_nodes) if unknown_nodes: utils.err( "nodes '%s' do not appear to exist in configuration" % "', '".join(unknown_nodes) ) stopping_all = set(nodes) >= set(all_nodes) if "--force" not in utils.pcs_options and not stopping_all: error_list = [] for node in nodes: retval, data = utils.get_remote_quorumtool_output(node) if retval != 0: error_list.append(node + ": " + data) continue # we are sure whether we are on cman cluster or not because only # nodes from a local cluster can be stopped (see nodes validation # above) if utils.is_rhel6(): quorum_info = utils.parse_cman_quorum_info(data) else: quorum_info = utils.parse_quorumtool_output(data) if quorum_info: if not quorum_info["quorate"]: continue if utils.is_node_stop_cause_quorum_loss( quorum_info, local=False, node_list=nodes ): utils.err( "Stopping the node(s) will cause a loss of the quorum" + ", use --force to override" ) else: # We have the info, no need to print errors error_list = [] break if not utils.is_node_offline_by_quorumtool_output(data): error_list.append("Unable to get quorum status") # else the node seems to be stopped already if error_list: utils.err( "Unable to determine whether stopping the nodes will cause " + "a loss of the quorum, use --force to override\n" + "\n".join(error_list) ) was_error = False node_errors = parallel_for_nodes(utils.stopPacemaker, nodes, quiet=True) accessible_nodes = [ node for node in nodes if node not in node_errors.keys() ] if node_errors: utils.err( "unable to stop all nodes\n" + "\n".join(node_errors.values()), exit_after_error=not accessible_nodes ) was_error = True for node in node_errors.keys(): print("{0}: Not stopping cluster - node is unreachable".format(node)) node_errors = parallel_for_nodes( utils.stopCorosync, accessible_nodes, quiet=True ) if node_errors: utils.err( "unable to stop all nodes\n" + "\n".join(node_errors.values()) ) if was_error: utils.err("unable to stop all nodes") def enable_cluster(argv): if len(argv) > 0: enable_cluster_nodes(argv) return try: utils.enableServices() except LibraryError as e: process_library_reports(e.args) def disable_cluster(argv): if len(argv) > 0: disable_cluster_nodes(argv) return try: utils.disableServices() except LibraryError as e: process_library_reports(e.args) def enable_cluster_all(): enable_cluster_nodes(utils.getNodesFromCorosyncConf()) def disable_cluster_all(): disable_cluster_nodes(utils.getNodesFromCorosyncConf()) def enable_cluster_nodes(nodes): error_list = utils.map_for_error_list(utils.enableCluster, nodes) if len(error_list) > 0: utils.err("unable to enable all nodes\n" + "\n".join(error_list)) def disable_cluster_nodes(nodes): error_list = utils.map_for_error_list(utils.disableCluster, nodes) if len(error_list) > 0: utils.err("unable to disable all nodes\n" + "\n".join(error_list)) def destroy_cluster(argv, keep_going=False): if len(argv) > 0: # stop pacemaker and resources while cluster is still quorate nodes = argv node_errors = parallel_for_nodes(utils.stopPacemaker, nodes, quiet=True) # proceed with destroy regardless of errors # destroy will stop any remaining cluster daemons node_errors = parallel_for_nodes(utils.destroyCluster, nodes, quiet=True) if node_errors: if keep_going: print( "Warning: unable to destroy cluster\n" + "\n".join(node_errors.values()) ) else: utils.err( "unable to destroy cluster\n" + "\n".join(node_errors.values()) ) def stop_cluster(argv): if len(argv) > 0: stop_cluster_nodes(argv) return if "--force" not in utils.pcs_options: if utils.is_rhel6(): output_status, dummy_retval = utils.run(["cman_tool", "status"]) output_nodes, dummy_retval = utils.run([ "cman_tool", "nodes", "-F", "id,type,votes,name" ]) if output_status == output_nodes: # when both commands return the same error output = output_status else: output = output_status + "\n---Votes---\n" + output_nodes quorum_info = utils.parse_cman_quorum_info(output) else: output, dummy_retval = utils.run(["corosync-quorumtool", "-p", "-s"]) # retval is 0 on success if node is not in partition with quorum # retval is 1 on error OR on success if node has quorum quorum_info = utils.parse_quorumtool_output(output) if quorum_info: if utils.is_node_stop_cause_quorum_loss(quorum_info, local=True): utils.err( "Stopping the node will cause a loss of the quorum" + ", use --force to override" ) elif not utils.is_node_offline_by_quorumtool_output(output): utils.err( "Unable to determine whether stopping the node will cause " + "a loss of the quorum, use --force to override" ) # else the node seems to be stopped already, proceed to be sure stop_all = ( "--pacemaker" not in utils.pcs_options and "--corosync" not in utils.pcs_options ) if stop_all or "--pacemaker" in utils.pcs_options: stop_cluster_pacemaker() if stop_all or "--corosync" in utils.pcs_options: stop_cluster_corosync() def stop_cluster_pacemaker(): print("Stopping Cluster (pacemaker)...") if not is_systemctl(): command = ["service", "pacemaker", "stop"] # If --skip-cman is not specified, pacemaker init script will stop cman # and corosync as well. That way some of the nodes may stop cman before # others stop pacemaker, which leads to quorum loss. We need to keep # quorum until all pacemaker resources are stopped as some of them may # need quorum to be able to stop. if utils.is_cman_cluster(): command.append("--skip-cman") else: command = ["systemctl", "stop", "pacemaker"] output, retval = utils.run(command) if retval != 0: print(output) utils.err("unable to stop pacemaker") def stop_cluster_corosync(): if utils.is_rhel6(): print("Stopping Cluster (cman)...") output, retval = utils.stop_service("cman") if retval != 0: print(output) utils.err("unable to stop cman") else: print("Stopping Cluster (corosync)...") service_list = [] if utils.need_to_handle_qdevice_service(): service_list.append("corosync-qdevice") service_list.append("corosync") for service in service_list: output, retval = utils.stop_service(service) if retval != 0: print(output) utils.err("unable to stop {0}".format(service)) def kill_cluster(argv): daemons = [ "crmd", "pengine", "attrd", "lrmd", "stonithd", "cib", "pacemakerd", "pacemaker_remoted", "corosync-qdevice", "corosync", ] dummy_output, dummy_retval = utils.run(["killall", "-9"] + daemons) # if dummy_retval != 0: # print "Error: unable to execute killall -9" # print output # sys.exit(1) def cluster_push(argv): if len(argv) > 2: usage.cluster(["cib-push"]) sys.exit(1) filename = None scope = None timeout = None if "--wait" in utils.pcs_options: timeout = utils.validate_wait_get_timeout() for arg in argv: if "=" not in arg: filename = arg else: arg_name, arg_value = arg.split("=", 1) if arg_name == "scope" and "--config" not in utils.pcs_options: if not utils.is_valid_cib_scope(arg_value): utils.err("invalid CIB scope '%s'" % arg_value) else: scope = arg_value else: usage.cluster(["cib-push"]) sys.exit(1) if "--config" in utils.pcs_options: scope = "configuration" if not filename: usage.cluster(["cib-push"]) sys.exit(1) try: new_cib_dom = xml.dom.minidom.parse(filename) if scope and not new_cib_dom.getElementsByTagName(scope): utils.err( "unable to push cib, scope '%s' not present in new cib" % scope ) except (EnvironmentError, xml.parsers.expat.ExpatError) as e: utils.err("unable to parse new cib: %s" % e) command = ["cibadmin", "--replace", "--xml-file", filename] if scope: command.append("--scope=%s" % scope) output, retval = utils.run(command) if retval != 0: utils.err("unable to push cib\n" + output) print("CIB updated") if "--wait" not in utils.pcs_options: return cmd = ["crm_resource", "--wait"] if timeout: cmd.extend(["--timeout", timeout]) output, retval = utils.run(cmd) if retval != 0: msg = [] if retval == settings.pacemaker_wait_timeout_status: msg.append("waiting timeout") if output: msg.append("\n" + output) utils.err("\n".join(msg).strip()) def cluster_edit(argv): if 'EDITOR' in os.environ: if len(argv) > 1: usage.cluster(["edit"]) sys.exit(1) scope = None scope_arg = "" for arg in argv: if "=" not in arg: usage.cluster(["edit"]) sys.exit(1) else: arg_name, arg_value = arg.split("=", 1) if arg_name == "scope" and "--config" not in utils.pcs_options: if not utils.is_valid_cib_scope(arg_value): utils.err("invalid CIB scope '%s'" % arg_value) else: scope_arg = arg scope = arg_value else: usage.cluster(["edit"]) sys.exit(1) if "--config" in utils.pcs_options: scope = "configuration" # Leave scope_arg empty as cluster_push will pick up a --config # option from utils.pcs_options scope_arg = "" editor = os.environ['EDITOR'] tempcib = tempfile.NamedTemporaryFile(mode="w+", suffix=".pcs") cib = utils.get_cib(scope) tempcib.write(cib) tempcib.flush() try: subprocess.call([editor, tempcib.name]) except OSError: utils.err("unable to open file with $EDITOR: " + editor) tempcib.seek(0) newcib = "".join(tempcib.readlines()) if newcib == cib: print("CIB not updated, no changes detected") else: cluster_push([arg for arg in [tempcib.name, scope_arg] if arg]) else: utils.err("$EDITOR environment variable is not set") def get_cib(argv): if len(argv) > 2: usage.cluster(["cib"]) sys.exit(1) filename = None scope = None for arg in argv: if "=" not in arg: filename = arg else: arg_name, arg_value = arg.split("=", 1) if arg_name == "scope" and "--config" not in utils.pcs_options: if not utils.is_valid_cib_scope(arg_value): utils.err("invalid CIB scope '%s'" % arg_value) else: scope = arg_value else: usage.cluster(["cib"]) sys.exit(1) if "--config" in utils.pcs_options: scope = "configuration" if not filename: print(utils.get_cib(scope), end="") else: try: f = open(filename, 'w') output = utils.get_cib(scope) if output != "": f.write(output) else: utils.err("No data in the CIB") except IOError as e: utils.err("Unable to write to file '%s', %s" % (filename, e.strerror)) def _ensure_cluster_is_offline_if_atb_should_be_enabled( lib_env, node_num_modifier, skip_offline_nodes=False ): """ Check if cluster is offline if auto tie breaker should be enabled. Raises LibraryError if ATB needs to be enabled cluster is not offline. lib_env -- LibraryEnvironment node_num_modifier -- number which wil be added to the number of nodes in cluster when determining whenever ATB is needed. skip_offline_nodes -- if True offline nodes will be skipped """ if not lib_env.is_cman_cluster: corosync_conf = lib_env.get_corosync_conf() if lib_sbd.atb_has_to_be_enabled( lib_env.cmd_runner(), corosync_conf, node_num_modifier ): print( "Warning: auto_tie_breaker quorum option will be enabled to " "make SBD fencing effecive after this change. Cluster has to " "be offline to be able to make this change." ) check_corosync_offline_on_nodes( lib_env.node_communicator(), lib_env.report_processor, corosync_conf.get_nodes(), skip_offline_nodes ) def cluster_node(argv): if len(argv) != 2: usage.cluster() sys.exit(1) if argv[0] == "add": add_node = True elif argv[0] in ["remove","delete"]: add_node = False else: usage.cluster() sys.exit(1) node = argv[1] node0, node1 = utils.parse_multiring_node(node) if not node0: utils.err("missing ring 0 address of the node") # allow to continue if removing a node with --force if add_node or "--force" not in utils.pcs_options: status, output = utils.checkAuthorization(node0) if status != 0: if status == 2: msg = "pcsd is not running on {0}".format(node0) elif status == 3: msg = ( "{node} is not yet authenticated " + " (try pcs cluster auth {node})" ).format(node=node0) else: msg = output if not add_node: msg += ", use --force to override" utils.err(msg) lib_env = utils.get_lib_env() modifiers = utils.get_modificators() if add_node == True: wait = False wait_timeout = None if "--start" in utils.pcs_options and "--wait" in utils.pcs_options: wait_timeout = utils.validate_wait_get_timeout(False) wait = True need_ring1_address = utils.need_ring1_address(utils.getCorosyncConf()) if not node1 and need_ring1_address: utils.err( "cluster is configured for RRP, " "you have to specify ring 1 address for the node" ) elif node1 and not need_ring1_address: utils.err( "cluster is not configured for RRP, " "you must not specify ring 1 address for the node" ) (canAdd, error) = utils.canAddNodeToCluster(node0) if not canAdd: utils.err("Unable to add '%s' to cluster: %s" % (node0, error)) report_processor = lib_env.report_processor node_communicator = lib_env.node_communicator() node_addr = NodeAddresses(node0, node1) # First set up everything else than corosync. Once the new node is # present in corosync.conf / cluster.conf, it's considered part of a # cluster and the node add command cannot be run again. So we need to # minimize the amout of actions (and therefore possible failures) after # adding the node to corosync. try: # qdevice setup if not utils.is_rhel6(): conf_facade = corosync_conf_facade.from_string( utils.getCorosyncConf() ) qdevice_model, qdevice_model_options, _ = conf_facade.get_quorum_device_settings() if qdevice_model == "net": _add_device_model_net( lib_env, qdevice_model_options["host"], conf_facade.get_cluster_name(), [node_addr], skip_offline_nodes=False ) # sbd setup if lib_sbd.is_sbd_enabled(utils.cmd_runner()): if "--watchdog" not in utils.pcs_options: watchdog = settings.sbd_watchdog_default print("Warning: using default watchdog '{0}'".format( watchdog )) else: watchdog = utils.pcs_options["--watchdog"][0] _ensure_cluster_is_offline_if_atb_should_be_enabled( lib_env, 1, modifiers["skip_offline_nodes"] ) report_processor.process(lib_reports.sbd_check_started()) lib_sbd.check_sbd_on_node( report_processor, node_communicator, node_addr, watchdog ) sbd_cfg = environment_file_to_dict( lib_sbd.get_local_sbd_config() ) report_processor.process( lib_reports.sbd_config_distribution_started() ) lib_sbd.set_sbd_config_on_node( report_processor, node_communicator, node_addr, sbd_cfg, watchdog ) report_processor.process(lib_reports.sbd_enabling_started()) lib_sbd.enable_sbd_service_on_node( report_processor, node_communicator, node_addr ) else: report_processor.process(lib_reports.sbd_disabling_started()) lib_sbd.disable_sbd_service_on_node( report_processor, node_communicator, node_addr ) # booth setup booth_sync.send_all_config_to_node( node_communicator, report_processor, node_addr, rewrite_existing=modifiers["force"], skip_wrong_config=modifiers["force"] ) except LibraryError as e: process_library_reports(e.args) except NodeCommunicationException as e: process_library_reports( [node_communicator_exception_to_report_item(e)] ) # Now add the new node to corosync.conf / cluster.conf corosync_conf = None for my_node in utils.getNodesFromCorosyncConf(): retval, output = utils.addLocalNode(my_node, node0, node1) if retval != 0: utils.err( "unable to add %s on %s - %s" % (node0, my_node, output.strip()), False ) else: print("%s: Corosync updated" % my_node) corosync_conf = output # corosync.conf must be reloaded before the new node is started output, retval = utils.reloadCorosync() if corosync_conf != None: # send local cluster pcsd configs to the new node # may be used for sending corosync config as well in future pcsd_data = { 'nodes': [node0], 'force': True, } output, retval = utils.run_pcsdcli('send_local_configs', pcsd_data) if retval != 0: utils.err("Unable to set pcsd configs") if output['status'] == 'notauthorized': utils.err( "Unable to authenticate to " + node0 + ", try running 'pcs cluster auth'" ) if output['status'] == 'ok' and output['data']: try: node_response = output['data'][node0] if node_response['status'] not in ['ok', 'not_supported']: utils.err("Unable to set pcsd configs") except: utils.err('Unable to communicate with pcsd') print("Setting up corosync...") utils.setCorosyncConfig(node0, corosync_conf) if "--enable" in utils.pcs_options: retval, err = utils.enableCluster(node0) if retval != 0: print("Warning: enable cluster - {0}".format(err)) if "--start" in utils.pcs_options or utils.is_rhel6(): # always start new node on cman cluster # otherwise it will get fenced retval, err = utils.startCluster(node0) if retval != 0: print("Warning: start cluster - {0}".format(err)) pcsd.pcsd_sync_certs([node0], exit_after_error=False) else: utils.err("Unable to update any nodes") if utils.is_cman_with_udpu_transport(): print("Warning: Using udpu transport on a CMAN cluster, " + "cluster restart is required to apply node addition") if wait: print() wait_for_nodes_started([node0], wait_timeout) else: if node0 not in utils.getNodesFromCorosyncConf(): utils.err( "node '%s' does not appear to exist in configuration" % node0 ) if "--force" not in utils.pcs_options: retval, data = utils.get_remote_quorumtool_output(node0) if retval != 0: utils.err( "Unable to determine whether removing the node will cause " + "a loss of the quorum, use --force to override\n" + data ) # we are sure whether we are on cman cluster or not because only # nodes from a local cluster can be stopped (see nodes validation # above) if utils.is_rhel6(): quorum_info = utils.parse_cman_quorum_info(data) else: quorum_info = utils.parse_quorumtool_output(data) if quorum_info: if utils.is_node_stop_cause_quorum_loss( quorum_info, local=False, node_list=[node0] ): utils.err( "Removing the node will cause a loss of the quorum" + ", use --force to override" ) elif not utils.is_node_offline_by_quorumtool_output(data): utils.err( "Unable to determine whether removing the node will cause " + "a loss of the quorum, use --force to override\n" + data ) # else the node seems to be stopped already, we're ok to proceed try: _ensure_cluster_is_offline_if_atb_should_be_enabled( lib_env, -1, modifiers["skip_offline_nodes"] ) except LibraryError as e: utils.process_library_reports(e.args) nodesRemoved = False c_nodes = utils.getNodesFromCorosyncConf() destroy_cluster([node0], keep_going=("--force" in utils.pcs_options)) for my_node in c_nodes: if my_node == node0: continue retval, output = utils.removeLocalNode(my_node, node0) if retval != 0: utils.err( "unable to remove %s on %s - %s" % (node0,my_node,output.strip()), False ) else: if output[0] == 0: print("%s: Corosync updated" % my_node) nodesRemoved = True else: utils.err( "%s: Error executing command occured: %s" % (my_node, "".join(output[1])), False ) if nodesRemoved == False: utils.err("Unable to update any nodes") output, retval = utils.reloadCorosync() output, retval = utils.run(["crm_node", "--force", "-R", node0]) if utils.is_cman_with_udpu_transport(): print("Warning: Using udpu transport on a CMAN cluster, " + "cluster restart is required to apply node removal") def cluster_localnode(argv): if len(argv) != 2: usage.cluster() exit(1) elif argv[0] == "add": node = argv[1] if not utils.is_rhel6(): success = utils.addNodeToCorosync(node) else: success = utils.addNodeToClusterConf(node) if success: print("%s: successfully added!" % node) else: utils.err("unable to add %s" % node) elif argv[0] in ["remove","delete"]: node = argv[1] if not utils.is_rhel6(): success = utils.removeNodeFromCorosync(node) else: success = utils.removeNodeFromClusterConf(node) # The removed node might be present in CIB. If it is, pacemaker will show it as # offline, no matter it's not in corosync / cman config any longer. We remove # the node by running 'crm_node -R ' on the node where the remove command # was ran. This only works if pacemaker is running. If it's not, we need # to remove the node manually from the CIB on all nodes. cib_node_remove = None if utils.usefile: cib_node_remove = utils.filename elif not utils.is_service_running(utils.cmd_runner(), "pacemaker"): cib_node_remove = os.path.join(settings.cib_dir, "cib.xml") if cib_node_remove: original_usefile, original_filename = utils.usefile, utils.filename utils.usefile = True utils.filename = cib_node_remove dummy_output, dummy_retval = utils.run([ "cibadmin", "--delete-all", "--force", "--xpath=/cib/configuration/nodes/node[@uname='{0}']".format( node ), ]) utils.usefile, utils.filename = original_usefile, original_filename if success: print("%s: successfully removed!" % node) else: utils.err("unable to remove %s" % node) else: usage.cluster() exit(1) def cluster_uidgid_rhel6(argv, silent_list = False): if not os.path.isfile(settings.cluster_conf_file): utils.err("the file doesn't exist on this machine, create a cluster before running this command" % settings.cluster_conf_file) if len(argv) == 0: found = False output, retval = utils.run(["ccs", "-f", settings.cluster_conf_file, "--lsmisc"]) if retval != 0: utils.err("error running ccs\n" + output) lines = output.split('\n') for line in lines: if line.startswith('UID/GID: '): print(line) found = True if not found and not silent_list: print("No uidgids configured in cluster.conf") return command = argv.pop(0) uid="" gid="" if (command == "add" or command == "rm") and len(argv) > 0: for arg in argv: if arg.find('=') == -1: utils.err("uidgid options must be of the form uid= gid=") (k,v) = arg.split('=',1) if k != "uid" and k != "gid": utils.err("%s is not a valid key, you must use uid or gid" %k) if k == "uid": uid = v if k == "gid": gid = v if uid == "" and gid == "": utils.err("you must set either uid or gid") if command == "add": output, retval = utils.run(["ccs", "-f", settings.cluster_conf_file, "--setuidgid", "uid="+uid, "gid="+gid]) if retval != 0: utils.err("unable to add uidgid\n" + output.rstrip()) elif command == "rm": output, retval = utils.run(["ccs", "-f", settings.cluster_conf_file, "--rmuidgid", "uid="+uid, "gid="+gid]) if retval != 0: utils.err("unable to remove uidgid\n" + output.rstrip()) # If we make a change, we sync out the changes to all nodes unless we're using -f if not utils.usefile: sync_nodes(utils.getNodesFromCorosyncConf(), utils.getCorosyncConf()) else: usage.cluster(["uidgid"]) exit(1) def cluster_uidgid(argv, silent_list = False): if utils.is_rhel6(): cluster_uidgid_rhel6(argv, silent_list) return if len(argv) == 0: found = False uid_gid_files = os.listdir(settings.corosync_uidgid_dir) for ug_file in uid_gid_files: uid_gid_dict = utils.read_uid_gid_file(ug_file) if "uid" in uid_gid_dict or "gid" in uid_gid_dict: line = "UID/GID: uid=" if "uid" in uid_gid_dict: line += uid_gid_dict["uid"] line += " gid=" if "gid" in uid_gid_dict: line += uid_gid_dict["gid"] print(line) found = True if not found and not silent_list: print("No uidgids configured in cluster.conf") return command = argv.pop(0) uid="" gid="" if (command == "add" or command == "rm") and len(argv) > 0: for arg in argv: if arg.find('=') == -1: utils.err("uidgid options must be of the form uid= gid=") (k,v) = arg.split('=',1) if k != "uid" and k != "gid": utils.err("%s is not a valid key, you must use uid or gid" %k) if k == "uid": uid = v if k == "gid": gid = v if uid == "" and gid == "": utils.err("you must set either uid or gid") if command == "add": utils.write_uid_gid_file(uid,gid) elif command == "rm": retval = utils.remove_uid_gid_file(uid,gid) if retval == False: utils.err("no uidgid files with uid=%s and gid=%s found" % (uid,gid)) else: usage.cluster(["uidgid"]) exit(1) def cluster_get_corosync_conf(argv): if utils.is_rhel6(): utils.err("corosync.conf is not supported on CMAN clusters") if len(argv) > 1: usage.cluster() exit(1) if len(argv) == 0: print(utils.getCorosyncConf(), end="") return node = argv[0] retval, output = utils.getCorosyncConfig(node) if retval != 0: utils.err(output) else: print(output, end="") def cluster_reload(argv): if len(argv) != 1 or argv[0] != "corosync": usage.cluster(["reload"]) exit(1) output, retval = utils.reloadCorosync() if retval != 0 or "invalid option" in output: utils.err(output.rstrip()) print("Corosync reloaded") # Completely tear down the cluster & remove config files # Code taken from cluster-clean script in pacemaker def cluster_destroy(argv): if "--all" in utils.pcs_options: destroy_cluster(utils.getNodesFromCorosyncConf()) else: print("Shutting down pacemaker/corosync services...") for service in ["pacemaker", "corosync-qdevice", "corosync"]: # Returns an error if a service is not running. It is safe to # ignore it since we want it not to be running anyways. utils.stop_service(service) print("Killing any remaining services...") os.system("killall -q -9 corosync corosync-qdevice aisexec heartbeat pacemakerd ccm stonithd ha_logd lrmd crmd pengine attrd pingd mgmtd cib fenced dlm_controld gfs_controld") try: utils.disableServices() except: # previously errors were suppressed in here, let's keep it that way # for now pass try: disable_service(utils.cmd_runner(), lib_sbd.get_sbd_service_name()) except: # it's not a big deal if sbd disable fails pass print("Removing all cluster configuration files...") if utils.is_rhel6(): os.system("rm -f /etc/cluster/cluster.conf") else: os.system("rm -f /etc/corosync/corosync.conf") state_files = ["cib.xml*", "cib-*", "core.*", "hostcache", "cts.*", "pe*.bz2","cib.*"] for name in state_files: os.system("find /var/lib -name '"+name+"' -exec rm -f \{\} \;") try: qdevice_net.client_destroy() except: # errors from deleting other files are suppressed as well # we do not want to fail if qdevice was not set up pass def cluster_verify(argv): nofilename = True if len(argv) == 1: filename = argv.pop(0) nofilename = False elif len(argv) > 1: usage.cluster("verify") options = [] if "-V" in utils.pcs_options: options.append("-V") if nofilename: options.append("--live-check") else: options.append("--xml-file") options.append(filename) output, retval = utils.run([settings.crm_verify] + options) if output != "": print(output) stonith.stonith_level_verify() return retval def cluster_report(argv): if len(argv) != 1: usage.cluster(["report"]) sys.exit(1) outfile = argv[0] dest_outfile = outfile + ".tar.bz2" if os.path.exists(dest_outfile): if "--force" not in utils.pcs_options: utils.err(dest_outfile + " already exists, use --force to overwrite") else: try: os.remove(dest_outfile) except OSError as e: utils.err("Unable to remove " + dest_outfile + ": " + e.strerror) crm_report_opts = [] crm_report_opts.append("-f") if "--from" in utils.pcs_options: crm_report_opts.append(utils.pcs_options["--from"]) if "--to" in utils.pcs_options: crm_report_opts.append("-t") crm_report_opts.append(utils.pcs_options["--to"]) else: yesterday = datetime.datetime.now() - datetime.timedelta(1) crm_report_opts.append(yesterday.strftime("%Y-%m-%d %H:%M")) crm_report_opts.append(outfile) output, retval = utils.run([settings.crm_report] + crm_report_opts) newoutput = "" for line in output.split("\n"): if line.startswith("cat:") or line.startswith("grep") or line.startswith("grep") or line.startswith("tail"): continue if "We will attempt to remove" in line: continue if "-p option" in line: continue if "However, doing" in line: continue if "to diagnose" in line: continue newoutput = newoutput + line + "\n" if retval != 0: utils.err(newoutput) print(newoutput) def cluster_remote_node(argv): if len(argv) < 1: usage.cluster(["remote-node"]) sys.exit(1) command = argv.pop(0) if command == "add": if len(argv) < 2: usage.cluster(["remote-node"]) sys.exit(1) hostname = argv.pop(0) rsc = argv.pop(0) if not utils.dom_get_resource(utils.get_cib_dom(), rsc): utils.err("unable to find resource '%s'" % rsc) resource.resource_update(rsc, ["meta", "remote-node="+hostname] + argv) elif command in ["remove","delete"]: if len(argv) < 1: usage.cluster(["remote-node"]) sys.exit(1) hostname = argv.pop(0) dom = utils.get_cib_dom() nvpairs = dom.getElementsByTagName("nvpair") nvpairs_to_remove = [] for nvpair in nvpairs: if nvpair.getAttribute("name") == "remote-node" and nvpair.getAttribute("value") == hostname: for np in nvpair.parentNode.getElementsByTagName("nvpair"): if np.getAttribute("name").startswith("remote-"): nvpairs_to_remove.append(np) if len(nvpairs_to_remove) == 0: utils.err("unable to remove: cannot find remote-node '%s'" % hostname) for nvpair in nvpairs_to_remove[:]: nvpair.parentNode.removeChild(nvpair) dom = constraint.remove_constraints_containing_node(dom, hostname) utils.replace_cib_configuration(dom) if not utils.usefile: output, retval = utils.run([ "crm_node", "--force", "--remove", hostname ]) if retval != 0: utils.err("unable to remove: {0}".format(output)) else: usage.cluster(["remote-node"]) sys.exit(1) pcs-0.9.155/pcs/common/000077500000000000000000000000001301012375000145255ustar00rootroot00000000000000pcs-0.9.155/pcs/common/__init__.py000066400000000000000000000000001301012375000166240ustar00rootroot00000000000000pcs-0.9.155/pcs/common/env_file_role_codes.py000066400000000000000000000002371301012375000210660ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) BOOTH_CONFIG = "BOOTH_CONFIG" BOOTH_KEY = "BOOTH_KEY" pcs-0.9.155/pcs/common/report_codes.py000066400000000000000000000245541301012375000176010ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) # force cathegories FORCE_ACTIVE_RRP = "ACTIVE_RRP" FORCE_ALERT_RECIPIENT_VALUE_NOT_UNIQUE = "FORCE_ALERT_RECIPIENT_VALUE_NOT_UNIQUE" FORCE_BOOTH_DESTROY = "FORCE_BOOTH_DESTROY" FORCE_BOOTH_REMOVE_FROM_CIB = "FORCE_BOOTH_REMOVE_FROM_CIB" FORCE_CONSTRAINT_DUPLICATE = "CONSTRAINT_DUPLICATE" FORCE_CONSTRAINT_MULTIINSTANCE_RESOURCE = "CONSTRAINT_MULTIINSTANCE_RESOURCE" FORCE_FILE_OVERWRITE = "FORCE_FILE_OVERWRITE" FORCE_LOAD_THRESHOLD = "LOAD_THRESHOLD" FORCE_METADATA_ISSUE = "METADATA_ISSUE" FORCE_OPTIONS = "OPTIONS" FORCE_QDEVICE_MODEL = "QDEVICE_MODEL" FORCE_QDEVICE_USED = "QDEVICE_USED" SKIP_OFFLINE_NODES = "SKIP_OFFLINE_NODES" SKIP_UNREADABLE_CONFIG = "SKIP_UNREADABLE_CONFIG" AGENT_NAME_GUESS_FOUND_MORE_THAN_ONE = "AGENT_NAME_GUESS_FOUND_MORE_THAN_ONE" AGENT_NAME_GUESS_FOUND_NONE = "AGENT_NAME_GUESS_FOUND_NONE" AGENT_NAME_GUESSED = "AGENT_NAME_GUESSED" BAD_CLUSTER_STATE_FORMAT = 'BAD_CLUSTER_STATE_FORMAT' BOOTH_ADDRESS_DUPLICATION = "BOOTH_ADDRESS_DUPLICATION" BOOTH_ALREADY_IN_CIB = "BOOTH_ALREADY_IN_CIB" BOOTH_CANNOT_DETERMINE_LOCAL_SITE_IP = "BOOTH_CANNOT_DETERMINE_LOCAL_SITE_IP" BOOTH_CANNOT_IDENTIFY_KEYFILE = "BOOTH_CANNOT_IDENTIFY_KEYFILE" BOOTH_CONFIG_ACCEPTED_BY_NODE = "BOOTH_CONFIG_ACCEPTED_BY_NODE" BOOTH_CONFIG_DISTRIBUTION_NODE_ERROR = "BOOTH_CONFIG_DISTRIBUTION_NODE_ERROR" BOOTH_CONFIG_DISTRIBUTION_STARTED = "BOOTH_CONFIG_DISTRIBUTION_STARTED" BOOTH_CONFIG_FILE_ALREADY_EXISTS = "BOOTH_CONFIG_FILE_ALREADY_EXISTS" BOOTH_CONFIG_IO_ERROR = "BOOTH_CONFIG_IO_ERROR" BOOTH_CONFIG_IS_USED = "BOOTH_CONFIG_IS_USED" BOOTH_CONFIG_READ_ERROR = "BOOTH_CONFIG_READ_ERROR" BOOTH_CONFIG_UNEXPECTED_LINES = "BOOTH_CONFIG_UNEXPECTED_LINES" BOOTH_DAEMON_STATUS_ERROR = "BOOTH_DAEMON_STATUS_ERROR" BOOTH_EVEN_PEERS_NUM = "BOOTH_EVEN_PEERS_NUM" BOOTH_FETCHING_CONFIG_FROM_NODE = "BOOTH_FETCHING_CONFIG_FROM_NODE" BOOTH_INVALID_CONFIG_NAME = "BOOTH_INVALID_CONFIG_NAME" BOOTH_INVALID_NAME = "BOOTH_INVALID_NAME" BOOTH_LACK_OF_SITES = "BOOTH_LACK_OF_SITES" BOOTH_MULTIPLE_TIMES_IN_CIB = "BOOTH_MULTIPLE_TIMES_IN_CIB" BOOTH_NOT_EXISTS_IN_CIB = "BOOTH_NOT_EXISTS_IN_CIB" BOOTH_PEERS_STATUS_ERROR = "BOOTH_PEERS_STATUS_ERROR" BOOTH_SKIPPING_CONFIG = "BOOTH_SKIPPING_CONFIG" BOOTH_TICKET_DOES_NOT_EXIST = "BOOTH_TICKET_DOES_NOT_EXIST" BOOTH_TICKET_DUPLICATE = "BOOTH_TICKET_DUPLICATE" BOOTH_TICKET_NAME_INVALID = "BOOTH_TICKET_NAME_INVALID" BOOTH_TICKET_OPERATION_FAILED = "BOOTH_TICKET_OPERATION_FAILED" BOOTH_TICKET_STATUS_ERROR = "BOOTH_TICKET_STATUS_ERROR" BOOTH_UNSUPORTED_FILE_LOCATION = "BOOTH_UNSUPORTED_FILE_LOCATION" CIB_ACL_ROLE_IS_ALREADY_ASSIGNED_TO_TARGET = "CIB_ACL_ROLE_IS_ALREADY_ASSIGNED_TO_TARGET" CIB_ACL_ROLE_IS_NOT_ASSIGNED_TO_TARGET = "CIB_ACL_ROLE_IS_NOT_ASSIGNED_TO_TARGET" CIB_ACL_TARGET_ALREADY_EXISTS = "CIB_ACL_TARGET_ALREADY_EXISTS" CIB_ALERT_NOT_FOUND = "CIB_ALERT_NOT_FOUND" CIB_ALERT_RECIPIENT_ALREADY_EXISTS = "CIB_ALERT_RECIPIENT_ALREADY_EXISTS" CIB_ALERT_RECIPIENT_VALUE_INVALID = "CIB_ALERT_RECIPIENT_VALUE_INVALID" CIB_CANNOT_FIND_MANDATORY_SECTION = "CIB_CANNOT_FIND_MANDATORY_SECTION" CIB_LOAD_ERROR_BAD_FORMAT = "CIB_LOAD_ERROR_BAD_FORMAT" CIB_LOAD_ERROR = "CIB_LOAD_ERROR" CIB_LOAD_ERROR_SCOPE_MISSING = "CIB_LOAD_ERROR_SCOPE_MISSING" CIB_PUSH_ERROR = "CIB_PUSH_ERROR" CIB_UPGRADE_FAILED = "CIB_UPGRADE_FAILED" CIB_UPGRADE_FAILED_TO_MINIMAL_REQUIRED_VERSION = "CIB_UPGRADE_FAILED_TO_MINIMAL_REQUIRED_VERSION" CIB_UPGRADE_SUCCESSFUL = "CIB_UPGRADE_SUCCESSFUL" CLUSTER_CONF_LOAD_ERROR_INVALID_FORMAT = "CLUSTER_CONF_LOAD_ERROR_INVALID_FORMAT" CLUSTER_CONF_READ_ERROR = "CLUSTER_CONF_READ_ERROR" CLUSTER_RESTART_REQUIRED_TO_APPLY_CHANGES = "CLUSTER_RESTART_REQUIRED_TO_APPLY_CHANGES" CMAN_BROADCAST_ALL_RINGS = 'CMAN_BROADCAST_ALL_RINGS' CMAN_UDPU_RESTART_REQUIRED = 'CMAN_UDPU_RESTART_REQUIRED' CMAN_UNSUPPORTED_COMMAND = "CMAN_UNSUPPORTED_COMMAND" COMMON_ERROR = 'COMMON_ERROR' COMMON_INFO = 'COMMON_INFO' LIVE_ENVIRONMENT_REQUIRED = "LIVE_ENVIRONMENT_REQUIRED" COROSYNC_CONFIG_ACCEPTED_BY_NODE = "COROSYNC_CONFIG_ACCEPTED_BY_NODE" COROSYNC_CONFIG_DISTRIBUTION_STARTED = "COROSYNC_CONFIG_DISTRIBUTION_STARTED" COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR = "COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR" COROSYNC_CONFIG_RELOADED = "COROSYNC_CONFIG_RELOADED" COROSYNC_CONFIG_RELOAD_ERROR = "COROSYNC_CONFIG_RELOAD_ERROR" COROSYNC_NOT_RUNNING_CHECK_STARTED = "COROSYNC_NOT_RUNNING_CHECK_STARTED" COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR = "COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR" COROSYNC_NOT_RUNNING_ON_NODE = "COROSYNC_NOT_RUNNING_ON_NODE" COROSYNC_OPTIONS_INCOMPATIBLE_WITH_QDEVICE = "COROSYNC_OPTIONS_INCOMPATIBLE_WITH_QDEVICE" COROSYNC_QUORUM_CANNOT_DISABLE_ATB_DUE_TO_SBD = "COROSYNC_QUORUM_CANNOT_DISABLE_ATB_DUE_TO_SBD" COROSYNC_QUORUM_GET_STATUS_ERROR = "COROSYNC_QUORUM_GET_STATUS_ERROR" COROSYNC_QUORUM_SET_EXPECTED_VOTES_ERROR = "COROSYNC_QUORUM_SET_EXPECTED_VOTES_ERROR" COROSYNC_RUNNING_ON_NODE = "COROSYNC_RUNNING_ON_NODE" CRM_MON_ERROR = "CRM_MON_ERROR" DUPLICATE_CONSTRAINTS_EXIST = "DUPLICATE_CONSTRAINTS_EXIST" EMPTY_RESOURCE_SET_LIST = "EMPTY_RESOURCE_SET_LIST" EMPTY_ID = "EMPTY_ID" FILE_ALREADY_EXISTS = "FILE_ALREADY_EXISTS" FILE_DOES_NOT_EXIST = "FILE_DOES_NOT_EXIST" FILE_IO_ERROR = "FILE_IO_ERROR" ID_ALREADY_EXISTS = 'ID_ALREADY_EXISTS' ID_NOT_FOUND = 'ID_NOT_FOUND' IGNORED_CMAN_UNSUPPORTED_OPTION = 'IGNORED_CMAN_UNSUPPORTED_OPTION' INVALID_ID = "INVALID_ID" INVALID_OPTION = "INVALID_OPTION" INVALID_OPTION_VALUE = "INVALID_OPTION_VALUE" INVALID_RESOURCE_NAME = 'INVALID_RESOURCE_NAME' INVALID_RESOURCE_AGENT_NAME = 'INVALID_RESOURCE_AGENT_NAME' INVALID_RESPONSE_FORMAT = "INVALID_RESPONSE_FORMAT" INVALID_SCORE = "INVALID_SCORE" INVALID_TIMEOUT_VALUE = "INVALID_TIMEOUT_VALUE" MULTIPLE_SCORE_OPTIONS = "MULTIPLE_SCORE_OPTIONS" NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL = "NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL" NODE_COMMUNICATION_ERROR = "NODE_COMMUNICATION_ERROR" NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED = "NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED" NODE_COMMUNICATION_ERROR_PERMISSION_DENIED = "NODE_COMMUNICATION_ERROR_PERMISSION_DENIED" NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT = "NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT" NODE_COMMUNICATION_ERROR_UNSUPPORTED_COMMAND = "NODE_COMMUNICATION_ERROR_UNSUPPORTED_COMMAND" NODE_COMMUNICATION_FINISHED = "NODE_COMMUNICATION_FINISHED" NODE_COMMUNICATION_NOT_CONNECTED = "NODE_COMMUNICATION_NOT_CONNECTED" NODE_COMMUNICATION_STARTED = "NODE_COMMUNICATION_STARTED" NODE_NOT_FOUND = "NODE_NOT_FOUND" NON_UDP_TRANSPORT_ADDR_MISMATCH = 'NON_UDP_TRANSPORT_ADDR_MISMATCH' OMITTING_NODE = "OMITTING_NODE" PACEMAKER_LOCAL_NODE_NAME_NOT_FOUND = "PACEMAKER_LOCAL_NODE_NAME_NOT_FOUND" PARSE_ERROR_COROSYNC_CONF_MISSING_CLOSING_BRACE = "PARSE_ERROR_COROSYNC_CONF_MISSING_CLOSING_BRACE" PARSE_ERROR_COROSYNC_CONF = "PARSE_ERROR_COROSYNC_CONF" PARSE_ERROR_COROSYNC_CONF_UNEXPECTED_CLOSING_BRACE = "PARSE_ERROR_COROSYNC_CONF_UNEXPECTED_CLOSING_BRACE" QDEVICE_ALREADY_DEFINED = "QDEVICE_ALREADY_DEFINED" QDEVICE_ALREADY_INITIALIZED = "QDEVICE_ALREADY_INITIALIZED" QDEVICE_CERTIFICATE_ACCEPTED_BY_NODE = "QDEVICE_CERTIFICATE_ACCEPTED_BY_NODE" QDEVICE_CERTIFICATE_DISTRIBUTION_STARTED = "QDEVICE_CERTIFICATE_DISTRIBUTION_STARTED" QDEVICE_CERTIFICATE_REMOVAL_STARTED = "QDEVICE_CERTIFICATE_REMOVAL_STARTED" QDEVICE_CERTIFICATE_REMOVED_FROM_NODE = "QDEVICE_CERTIFICATE_REMOVED_FROM_NODE" QDEVICE_CERTIFICATE_IMPORT_ERROR = "QDEVICE_CERTIFICATE_IMPORT_ERROR" QDEVICE_CERTIFICATE_SIGN_ERROR = "QDEVICE_CERTIFICATE_SIGN_ERROR" QDEVICE_DESTROY_ERROR = "QDEVICE_DESTROY_ERROR" QDEVICE_DESTROY_SUCCESS = "QDEVICE_DESTROY_SUCCESS" QDEVICE_GET_STATUS_ERROR = "QDEVICE_GET_STATUS_ERROR" QDEVICE_INITIALIZATION_ERROR = "QDEVICE_INITIALIZATION_ERROR" QDEVICE_INITIALIZATION_SUCCESS = "QDEVICE_INITIALIZATION_SUCCESS" QDEVICE_NOT_DEFINED = "QDEVICE_NOT_DEFINED" QDEVICE_NOT_INITIALIZED = "QDEVICE_NOT_INITIALIZED" QDEVICE_NOT_RUNNING = "QDEVICE_NOT_RUNNING" QDEVICE_CLIENT_RELOAD_STARTED = "QDEVICE_CLIENT_RELOAD_STARTED" QDEVICE_REMOVE_OR_CLUSTER_STOP_NEEDED = "QDEVICE_REMOVE_OR_CLUSTER_STOP_NEEDED" QDEVICE_USED_BY_CLUSTERS = "QDEVICE_USED_BY_CLUSTERS" REQUIRED_OPTION_IS_MISSING = "REQUIRED_OPTION_IS_MISSING" RESOURCE_CLEANUP_ERROR = "RESOURCE_CLEANUP_ERROR" RESOURCE_CLEANUP_TOO_TIME_CONSUMING = 'RESOURCE_CLEANUP_TOO_TIME_CONSUMING' RESOURCE_DOES_NOT_EXIST = 'RESOURCE_DOES_NOT_EXIST' RESOURCE_FOR_CONSTRAINT_IS_MULTIINSTANCE = 'RESOURCE_FOR_CONSTRAINT_IS_MULTIINSTANCE' RESOURCE_WAIT_ERROR = "RESOURCE_WAIT_ERROR" RESOURCE_WAIT_NOT_SUPPORTED = "RESOURCE_WAIT_NOT_SUPPORTED" RESOURCE_WAIT_TIMED_OUT = "RESOURCE_WAIT_TIMED_OUT" RRP_ACTIVE_NOT_SUPPORTED = 'RRP_ACTIVE_NOT_SUPPORTED' RUN_EXTERNAL_PROCESS_ERROR = "RUN_EXTERNAL_PROCESS_ERROR" RUN_EXTERNAL_PROCESS_FINISHED = "RUN_EXTERNAL_PROCESS_FINISHED" RUN_EXTERNAL_PROCESS_STARTED = "RUN_EXTERNAL_PROCESS_STARTED" SBD_CHECK_STARTED = "SBD_CHECK_STARTED" SBD_CHECK_SUCCESS = "SBD_CHECK_SUCCESS" SBD_CONFIG_DISTRIBUTION_STARTED = "SBD_CONFIG_DISTRIBUTION_STARTED" SBD_CONFIG_ACCEPTED_BY_NODE = "SBD_CONFIG_ACCEPTED_BY_NODE" SBD_DISABLING_STARTED = "SBD_DISABLING_STARTED" SBD_ENABLING_STARTED = "SBD_ENABLING_STARTED" SBD_NOT_INSTALLED = "SBD_NOT_INSTALLED" SBD_NOT_ENABLED = "SBD_NOT_ENABLED" SBD_REQUIRES_ATB = "SBD_REQUIRES_ATB" SERVICE_DISABLE_ERROR = "SERVICE_DISABLE_ERROR" SERVICE_DISABLE_STARTED = "SERVICE_DISABLE_STARTED" SERVICE_DISABLE_SUCCESS = "SERVICE_DISABLE_SUCCESS" SERVICE_ENABLE_ERROR = "SERVICE_ENABLE_ERROR" SERVICE_ENABLE_STARTED = "SERVICE_ENABLE_STARTED" SERVICE_ENABLE_SKIPPED = "SERVICE_ENABLE_SKIPPED" SERVICE_ENABLE_SUCCESS = "SERVICE_ENABLE_SUCCESS" SERVICE_KILL_ERROR = "SERVICE_KILL_ERROR" SERVICE_KILL_SUCCESS = "SERVICE_KILL_SUCCESS" SERVICE_START_ERROR = "SERVICE_START_ERROR" SERVICE_START_SKIPPED = "SERVICE_START_SKIPPED" SERVICE_START_STARTED = "SERVICE_START_STARTED" SERVICE_START_SUCCESS = "SERVICE_START_SUCCESS" SERVICE_STOP_ERROR = "SERVICE_STOP_ERROR" SERVICE_STOP_STARTED = "SERVICE_STOP_STARTED" SERVICE_STOP_SUCCESS = "SERVICE_STOP_SUCCESS" UNABLE_TO_DETERMINE_USER_UID = "UNABLE_TO_DETERMINE_USER_UID" UNABLE_TO_DETERMINE_GROUP_GID = "UNABLE_TO_DETERMINE_GROUP_GID" UNABLE_TO_GET_AGENT_METADATA = 'UNABLE_TO_GET_AGENT_METADATA' UNABLE_TO_READ_COROSYNC_CONFIG = "UNABLE_TO_READ_COROSYNC_CONFIG" UNABLE_TO_GET_SBD_CONFIG = "UNABLE_TO_GET_SBD_CONFIG" UNABLE_TO_GET_SBD_STATUS = "UNABLE_TO_GET_SBD_STATUS" UNKNOWN_COMMAND = 'UNKNOWN_COMMAND' WATCHDOG_INVALID = "WATCHDOG_INVALID" UNSUPPORTED_OPERATION_ON_NON_SYSTEMD_SYSTEMS = "UNSUPPORTED_OPERATION_ON_NON_SYSTEMD_SYSTEMS" WATCHDOG_NOT_FOUND = "WATCHDOG_NOT_FOUND" pcs-0.9.155/pcs/common/test/000077500000000000000000000000001301012375000155045ustar00rootroot00000000000000pcs-0.9.155/pcs/common/test/__init__.py000066400000000000000000000000001301012375000176030ustar00rootroot00000000000000pcs-0.9.155/pcs/common/tools.py000066400000000000000000000016431301012375000162430ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import threading def simple_cache(func): cache = { "was_run": False, "value": None } def wrapper(): if not cache["was_run"]: cache["value"] = func() cache["was_run"] = True return cache["value"] return wrapper def run_parallel(worker, data_list): thread_list = [] for args, kwargs in data_list: thread = threading.Thread(target=worker, args=args, kwargs=kwargs) thread.daemon = True thread_list.append(thread) thread.start() for thread in thread_list: thread.join() def format_environment_error(e): if e.filename: return "{0}: '{1}'".format(e.strerror, e.filename) return e.strerror def join_multilines(strings): return "\n".join([a.strip() for a in strings if a.strip()]) pcs-0.9.155/pcs/config.py000066400000000000000000000702401301012375000150570ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import sys import os import os.path import re import datetime from io import BytesIO import tarfile import json from xml.dom.minidom import parse import logging import pwd import grp import time import platform try: import clufter.facts import clufter.format_manager import clufter.filter_manager import clufter.command_manager no_clufter = False except ImportError: no_clufter = True from pcs import ( cluster, constraint, prop, quorum, resource, settings, status, stonith, usage, utils, alert, ) from pcs.lib.errors import LibraryError from pcs.lib.commands import quorum as lib_quorum import pcs.cli.constraint_colocation.command as colocation_command import pcs.cli.constraint_order.command as order_command import pcs.cli.constraint_ticket.command as ticket_command from pcs.cli.common.console_report import indent def config_cmd(argv): if len(argv) == 0: config_show(argv) return sub_cmd = argv.pop(0) if sub_cmd == "help": usage.config(argv) elif sub_cmd == "show": config_show(argv) elif sub_cmd == "backup": config_backup(argv) elif sub_cmd == "restore": config_restore(argv) elif sub_cmd == "checkpoint": if not argv: config_checkpoint_list() elif argv[0] == "view": config_checkpoint_view(argv[1:]) elif argv[0] == "restore": config_checkpoint_restore(argv[1:]) else: usage.config(["checkpoint"]) sys.exit(1) elif sub_cmd == "import-cman": config_import_cman(argv) elif sub_cmd == "export": if not argv: usage.config(["export"]) sys.exit(1) elif argv[0] == "pcs-commands": config_export_pcs_commands(argv[1:]) elif argv[0] == "pcs-commands-verbose": config_export_pcs_commands(argv[1:], True) else: usage.config(["export"]) sys.exit(1) else: usage.config() sys.exit(1) def config_show(argv): print("Cluster Name: %s" % utils.getClusterName()) status.nodes_status(["config"]) print() config_show_cib() if ( utils.hasCorosyncConf() and ( utils.is_rhel6() or (not utils.usefile and "--corosync_conf" not in utils.pcs_options) ) ): # with corosync 1 and cman, uid gid is part of cluster.conf file # with corosync 2, uid gid is in a separate directory cluster.cluster_uidgid([], True) if ( "--corosync_conf" in utils.pcs_options or (not utils.is_rhel6() and utils.hasCorosyncConf()) ): print() print("Quorum:") try: config = lib_quorum.get_config(utils.get_lib_env()) print("\n".join(indent(quorum.quorum_config_to_str(config)))) except LibraryError as e: utils.process_library_reports(e.args) def config_show_cib(): print("Resources:") utils.pcs_options["--all"] = 1 utils.pcs_options["--full"] = 1 resource.resource_show([]) print() print("Stonith Devices:") resource.resource_show([], True) print("Fencing Levels:") stonith.stonith_level_show() print() lib = utils.get_library_wrapper() constraint.location_show([]) modificators = utils.get_modificators() order_command.show(lib, [], modificators) colocation_command.show(lib, [], modificators) ticket_command.show(lib, [], modificators) print() alert.print_alert_config(lib, [], modificators) print() del utils.pcs_options["--all"] print("Resources Defaults:") resource.show_defaults("rsc_defaults", indent=" ") print("Operations Defaults:") resource.show_defaults("op_defaults", indent=" ") print() prop.list_property([]) def config_backup(argv): if len(argv) > 1: usage.config(["backup"]) sys.exit(1) outfile_name = None if argv: outfile_name = argv[0] if not outfile_name.endswith(".tar.bz2"): outfile_name += ".tar.bz2" tar_data = config_backup_local() if outfile_name: ok, message = utils.write_file( outfile_name, tar_data, permissions=0o600, binary=True ) if not ok: utils.err(message) else: # in python3 stdout accepts str so we need to use buffer if hasattr(sys.stdout, "buffer"): sys.stdout.buffer.write(tar_data) else: sys.stdout.write(tar_data) def config_backup_local(): file_list = config_backup_path_list() tar_data = BytesIO() try: tarball = tarfile.open(fileobj=tar_data, mode="w|bz2") config_backup_add_version_to_tarball(tarball) for tar_path, path_info in file_list.items(): if ( not os.path.exists(path_info["path"]) and not path_info["required"] ): continue tarball.add(path_info["path"], tar_path) tarball.close() except (tarfile.TarError, EnvironmentError) as e: utils.err("unable to create tarball: %s" % e) tar = tar_data.getvalue() tar_data.close() return tar def config_restore(argv): if len(argv) > 1: usage.config(["restore"]) sys.exit(1) infile_name = infile_obj = None if argv: infile_name = argv[0] if not infile_name: # in python3 stdin returns str so we need to use buffer if hasattr(sys.stdin, "buffer"): infile_obj = BytesIO(sys.stdin.buffer.read()) else: infile_obj = BytesIO(sys.stdin.read()) if os.getuid() == 0: if "--local" in utils.pcs_options: config_restore_local(infile_name, infile_obj) else: config_restore_remote(infile_name, infile_obj) else: new_argv = ['config', 'restore'] new_stdin = None if '--local' in utils.pcs_options: new_argv.append('--local') if infile_name: new_argv.append(os.path.abspath(infile_name)) else: new_stdin = infile_obj.read() err_msgs, exitcode, std_out, std_err = utils.call_local_pcsd( new_argv, True, new_stdin ) if err_msgs: for msg in err_msgs: utils.err(msg, False) sys.exit(1) print(std_out) sys.stderr.write(std_err) sys.exit(exitcode) def config_restore_remote(infile_name, infile_obj): extracted = { "version.txt": "", "corosync.conf": "", "cluster.conf": "", } try: tarball = tarfile.open(infile_name, "r|*", infile_obj) while True: # next(tarball) does not work in python2.6 tar_member_info = tarball.next() if tar_member_info is None: break if tar_member_info.name in extracted: tar_member = tarball.extractfile(tar_member_info) extracted[tar_member_info.name] = tar_member.read() tar_member.close() tarball.close() except (tarfile.TarError, EnvironmentError) as e: utils.err("unable to read the tarball: %s" % e) config_backup_check_version(extracted["version.txt"]) node_list = utils.getNodesFromCorosyncConf( extracted["cluster.conf" if utils.is_rhel6() else "corosync.conf"].decode("utf-8") ) if not node_list: utils.err("no nodes found in the tarball") err_msgs = [] for node in node_list: try: retval, output = utils.checkStatus(node) if retval != 0: err_msgs.append(output) continue status = json.loads(output) if ( status["corosync"] or status["pacemaker"] or status["cman"] or # not supported by older pcsd, do not fail if not present status.get("pacemaker_remote", False) ): err_msgs.append( "Cluster is currently running on node %s. You need to stop " "the cluster in order to restore the configuration." % node ) continue except (ValueError, NameError, LookupError): err_msgs.append("unable to determine status of the node %s" % node) if err_msgs: for msg in err_msgs: utils.err(msg, False) sys.exit(1) # Temporarily disable config files syncing thread in pcsd so it will not # rewrite restored files. 10 minutes should be enough time to restore. # If node returns HTTP 404 it does not support config syncing at all. for node in node_list: retval, output = utils.pauseConfigSyncing(node, 10 * 60) if not (retval == 0 or "(HTTP error: 404)" in output): utils.err(output) if infile_obj: infile_obj.seek(0) tarball_data = infile_obj.read() else: with open(infile_name, "rb") as tarball: tarball_data = tarball.read() error_list = [] for node in node_list: retval, error = utils.restoreConfig(node, tarball_data) if retval != 0: error_list.append(error) if error_list: utils.err("unable to restore all nodes\n" + "\n".join(error_list)) def config_restore_local(infile_name, infile_obj): if ( status.is_service_running("cman") or status.is_service_running("corosync") or status.is_service_running("pacemaker") or status.is_service_running("pacemaker_remote") ): utils.err( "Cluster is currently running on this node. You need to stop " "the cluster in order to restore the configuration." ) file_list = config_backup_path_list(with_uid_gid=True) tarball_file_list = [] version = None try: tarball = tarfile.open(infile_name, "r|*", infile_obj) while True: # next(tarball) does not work in python2.6 tar_member_info = tarball.next() if tar_member_info is None: break if tar_member_info.name == "version.txt": version_data = tarball.extractfile(tar_member_info) version = version_data.read() version_data.close() continue tarball_file_list.append(tar_member_info.name) tarball.close() required_file_list = [ tar_path for tar_path, path_info in file_list.items() if path_info["required"] ] missing = set(required_file_list) - set(tarball_file_list) if missing: utils.err( "unable to restore the cluster, missing files in backup: %s" % ", ".join(missing) ) config_backup_check_version(version) if infile_obj: infile_obj.seek(0) tarball = tarfile.open(infile_name, "r|*", infile_obj) while True: # next(tarball) does not work in python2.6 tar_member_info = tarball.next() if tar_member_info is None: break extract_info = None path = tar_member_info.name while path: if path in file_list: extract_info = file_list[path] break path = os.path.dirname(path) if not extract_info: continue path_extract = os.path.dirname(extract_info["path"]) tarball.extractall(path_extract, [tar_member_info]) path_full = os.path.join(path_extract, tar_member_info.name) file_attrs = extract_info["attrs"] os.chmod(path_full, file_attrs["mode"]) os.chown(path_full, file_attrs["uid"], file_attrs["gid"]) tarball.close() except (tarfile.TarError, EnvironmentError) as e: utils.err("unable to restore the cluster: %s" % e) try: sig_path = os.path.join(settings.cib_dir, "cib.xml.sig") if os.path.exists(sig_path): os.remove(sig_path) except EnvironmentError as e: utils.err("unable to remove %s: %s" % (sig_path, e)) def config_backup_path_list(with_uid_gid=False, force_rhel6=None): rhel6 = utils.is_rhel6() if force_rhel6 is None else force_rhel6 corosync_attrs = { "mtime": int(time.time()), "mode": 0o644, "uname": "root", "gname": "root", "uid": 0, "gid": 0, } cib_attrs = { "mtime": int(time.time()), "mode": 0o600, "uname": settings.pacemaker_uname, "gname": settings.pacemaker_gname, } if with_uid_gid: try: cib_attrs["uid"] = pwd.getpwnam(cib_attrs["uname"]).pw_uid except KeyError: utils.err( "Unable to determine uid of user '%s'" % cib_attrs["uname"] ) try: cib_attrs["gid"] = grp.getgrnam(cib_attrs["gname"]).gr_gid except KeyError: utils.err( "Unable to determine gid of group '%s'" % cib_attrs["gname"] ) file_list = { "cib.xml": { "path": os.path.join(settings.cib_dir, "cib.xml"), "required": True, "attrs": dict(cib_attrs), }, } if rhel6: file_list["cluster.conf"] = { "path": settings.cluster_conf_file, "required": True, "attrs": dict(corosync_attrs), } else: file_list["corosync.conf"] = { "path": settings.corosync_conf_file, "required": True, "attrs": dict(corosync_attrs), } file_list["uidgid.d"] = { "path": settings.corosync_uidgid_dir.rstrip("/"), "required": False, "attrs": dict(corosync_attrs), } file_list["pcs_settings.conf"] = { "path": settings.pcsd_settings_conf_location, "required": False, "attrs": { "mtime": int(time.time()), "mode": 0o644, "uname": "root", "gname": "root", "uid": 0, "gid": 0, }, } return file_list def config_backup_check_version(version): try: version_number = int(version) supported_version = config_backup_version() if version_number > supported_version: utils.err( "Unsupported version of the backup, " "supported version is %d, backup version is %d" % (supported_version, version_number) ) if version_number < supported_version: print( "Warning: restoring from the backup version %d, " "current supported version is %s" % (version_number, supported_version) ) except TypeError: utils.err("Cannot determine version of the backup") def config_backup_add_version_to_tarball(tarball, version=None): ver = version if version is not None else str(config_backup_version()) return utils.tar_add_file_data(tarball, ver.encode("utf-8"), "version.txt") def config_backup_version(): return 1 def config_checkpoint_list(): try: file_list = os.listdir(settings.cib_dir) except OSError as e: utils.err("unable to list checkpoints: %s" % e) cib_list = [] cib_name_re = re.compile("^cib-(\d+)\.raw$") for filename in file_list: match = cib_name_re.match(filename) if not match: continue file_path = os.path.join(settings.cib_dir, filename) try: if os.path.isfile(file_path): cib_list.append( (float(os.path.getmtime(file_path)), match.group(1)) ) except OSError: pass cib_list.sort() if not cib_list: print("No checkpoints available") return for cib_info in cib_list: print( "checkpoint %s: date %s" % (cib_info[1], datetime.datetime.fromtimestamp(round(cib_info[0]))) ) def config_checkpoint_view(argv): if len(argv) != 1: usage.config(["checkpoint", "view"]) sys.exit(1) utils.usefile = True utils.filename = os.path.join(settings.cib_dir, "cib-%s.raw" % argv[0]) if not os.path.isfile(utils.filename): utils.err("unable to read the checkpoint") config_show_cib() def config_checkpoint_restore(argv): if len(argv) != 1: usage.config(["checkpoint", "restore"]) sys.exit(1) cib_path = os.path.join(settings.cib_dir, "cib-%s.raw" % argv[0]) try: snapshot_dom = parse(cib_path) except Exception as e: utils.err("unable to read the checkpoint: %s" % e) utils.replace_cib_configuration(snapshot_dom) def config_import_cman(argv): if no_clufter: utils.err("Unable to perform a CMAN cluster conversion due to missing python-clufter package") # prepare convertor options cluster_conf = settings.cluster_conf_file dry_run_output = None output_format = "cluster.conf" if utils.is_rhel6() else "corosync.conf" dist = None invalid_args = False for arg in argv: if "=" in arg: name, value = arg.split("=", 1) if name == "input": cluster_conf = value elif name == "output": dry_run_output = value elif name == "output-format": if value in ( "cluster.conf", "corosync.conf", "pcs-commands", "pcs-commands-verbose", ): output_format = value else: invalid_args = True elif name == "dist": dist = value else: invalid_args = True else: invalid_args = True if ( output_format not in ("pcs-commands", "pcs-commands-verbose") and (dry_run_output and not dry_run_output.endswith(".tar.bz2")) ): dry_run_output += ".tar.bz2" if invalid_args or not dry_run_output: usage.config(["import-cman"]) sys.exit(1) debug = "--debug" in utils.pcs_options force = "--force" in utils.pcs_options interactive = "--interactive" in utils.pcs_options if dist is not None: if output_format == "cluster.conf": if not clufter.facts.cluster_pcs_flatiron("linux", dist.split(",")): utils.err("dist does not match output-format") elif output_format == "corosync.conf": if not clufter.facts.cluster_pcs_needle("linux", dist.split(",")): utils.err("dist does not match output-format") elif ( (output_format == "cluster.conf" and utils.is_rhel6()) or (output_format == "corosync.conf" and not utils.is_rhel6()) ): dist = ",".join(platform.linux_distribution(full_distribution_name=0)) elif output_format == "cluster.conf": dist = "redhat,6.7,Santiago" elif output_format == "corosync.conf": dist = "redhat,7.1,Maipo" else: # for output-format=pcs-command[-verbose] dist = ",".join(platform.linux_distribution(full_distribution_name=0)) clufter_args = { "input": str(cluster_conf), "cib": {"passin": "bytestring"}, "nocheck": force, "batch": True, "sys": "linux", "dist": dist, # Make it work on RHEL6 as well for sure "color": "always" if sys.stdout.isatty() else "never" } if interactive: if "EDITOR" not in os.environ: utils.err("$EDITOR environment variable is not set") clufter_args["batch"] = False clufter_args["editor"] = os.environ["EDITOR"] if debug: logging.getLogger("clufter").setLevel(logging.DEBUG) if output_format == "cluster.conf": clufter_args["ccs_pcmk"] = {"passin": "bytestring"} cmd_name = "ccs2pcs-flatiron" elif output_format == "corosync.conf": clufter_args["coro"] = {"passin": "struct"} cmd_name = "ccs2pcs-needle" elif output_format in ("pcs-commands", "pcs-commands-verbose"): clufter_args["output"] = {"passin": "bytestring"} clufter_args["start_wait"] = "60" clufter_args["tmp_cib"] = "tmp-cib.xml" clufter_args["force"] = force clufter_args["text_width"] = "80" clufter_args["silent"] = True clufter_args["noguidance"] = True if output_format == "pcs-commands-verbose": clufter_args["text_width"] = "-1" clufter_args["silent"] = False clufter_args["noguidance"] = False if clufter.facts.cluster_pcs_flatiron("linux", dist.split(",")): cmd_name = "ccs2pcscmd-flatiron" elif clufter.facts.cluster_pcs_needle("linux", dist.split(",")): cmd_name = "ccs2pcscmd-needle" else: utils.err( "unrecognized dist, try something recognized" + " (e. g. rhel,6.8 or redhat,7.3 or debian,7 or ubuntu,trusty)" ) clufter_args_obj = type(str("ClufterOptions"), (object, ), clufter_args) # run convertor run_clufter( cmd_name, clufter_args_obj, debug, force, "Error: unable to import cluster configuration" ) # save commands if output_format in ("pcs-commands", "pcs-commands-verbose"): ok, message = utils.write_file( dry_run_output, clufter_args_obj.output["passout"] ) if not ok: utils.err(message) return # put new config files into tarball file_list = config_backup_path_list( force_rhel6=(output_format == "cluster.conf") ) for file_item in file_list.values(): file_item["attrs"]["uname"] = "root" file_item["attrs"]["gname"] = "root" file_item["attrs"]["uid"] = 0 file_item["attrs"]["gid"] = 0 file_item["attrs"]["mode"] = 0o600 tar_data = BytesIO() try: tarball = tarfile.open(fileobj=tar_data, mode="w|bz2") config_backup_add_version_to_tarball(tarball) utils.tar_add_file_data( tarball, clufter_args_obj.cib["passout"].encode("utf-8"), "cib.xml", **file_list["cib.xml"]["attrs"] ) if output_format == "cluster.conf": utils.tar_add_file_data( tarball, clufter_args_obj.ccs_pcmk["passout"].encode("utf-8"), "cluster.conf", **file_list["cluster.conf"]["attrs"] ) else: # put uidgid into separate files fmt_simpleconfig = clufter.format_manager.FormatManager.init_lookup( 'simpleconfig' ).plugins['simpleconfig'] corosync_struct = [] uidgid_list = [] for section in clufter_args_obj.coro["passout"][2]: if section[0] == "uidgid": uidgid_list.append(section[1]) else: corosync_struct.append(section) corosync_conf_data = fmt_simpleconfig( "struct", ("corosync", (), corosync_struct) )("bytestring") utils.tar_add_file_data( tarball, corosync_conf_data.encode("utf-8"), "corosync.conf", **file_list["corosync.conf"]["attrs"] ) for uidgid in uidgid_list: uid = "" gid = "" for item in uidgid: if item[0] == "uid": uid = item[1] if item[0] == "gid": gid = item[1] filename = utils.get_uid_gid_file_name(uid, gid) uidgid_data = fmt_simpleconfig( "struct", ("corosync", (), [("uidgid", uidgid, None)]) )("bytestring") utils.tar_add_file_data( tarball, uidgid_data.encode("utf-8"), "uidgid.d/" + filename, **file_list["uidgid.d"]["attrs"] ) tarball.close() except (tarfile.TarError, EnvironmentError) as e: utils.err("unable to create tarball: %s" % e) tar_data.seek(0) #save tarball / remote restore if dry_run_output: ok, message = utils.write_file( dry_run_output, tar_data.read(), permissions=0o600, binary=True ) if not ok: utils.err(message) else: config_restore_remote(None, tar_data) tar_data.close() def config_export_pcs_commands(argv, verbose=False): if no_clufter: utils.err( "Unable to perform export due to missing python-clufter package" ) # parse options debug = "--debug" in utils.pcs_options force = "--force" in utils.pcs_options interactive = "--interactive" in utils.pcs_options invalid_args = False output_file = None dist = None for arg in argv: if "=" in arg: name, value = arg.split("=", 1) if name == "output": output_file = value elif name == "dist": dist = value else: invalid_args = True else: invalid_args = True # check options if invalid_args: usage.config(["export", "pcs-commands"]) sys.exit(1) # complete optional options if dist is None: dist = ",".join(platform.linux_distribution(full_distribution_name=0)) # prepare convertor options clufter_args = { "nocheck": force, "batch": True, "sys": "linux", "dist": dist, # Make it work on RHEL6 as well for sure "color": "always" if sys.stdout.isatty() else "never", "coro": settings.corosync_conf_file, "ccs": settings.cluster_conf_file, "start_wait": "60", "tmp_cib": "tmp-cib.xml", "force": force, "text_width": "80", "silent": True, "noguidance": True, } if output_file: clufter_args["output"] = {"passin": "bytestring"} else: clufter_args["output"] = "-" if interactive: if "EDITOR" not in os.environ: utils.err("$EDITOR environment variable is not set") clufter_args["batch"] = False clufter_args["editor"] = os.environ["EDITOR"] if debug: logging.getLogger("clufter").setLevel(logging.DEBUG) if utils.usefile: clufter_args["cib"] = os.path.abspath(utils.filename) else: clufter_args["cib"] = ("bytestring", utils.get_cib()) if verbose: clufter_args["text_width"] = "-1" clufter_args["silent"] = False clufter_args["noguidance"] = False clufter_args_obj = type(str("ClufterOptions"), (object, ), clufter_args) cmd_name = "pcs2pcscmd-flatiron" if utils.is_rhel6() else "pcs2pcscmd-needle" # run convertor run_clufter( cmd_name, clufter_args_obj, debug, force, "Error: unable to export cluster configuration" ) # save commands if not printed to stdout by clufter if output_file: ok, message = utils.write_file( output_file, clufter_args_obj.output["passout"] ) if not ok: utils.err(message) def run_clufter(cmd_name, cmd_args, debug, force, err_prefix): try: result = None cmd_manager = clufter.command_manager.CommandManager.init_lookup( cmd_name ) result = cmd_manager.commands[cmd_name](cmd_args) error_message = "" except Exception as e: error_message = str(e) if error_message or result != 0: hints = [] hints.append("--interactive to solve the issues manually") if not debug: hints.append("--debug to get more information") if not force: hints.append("--force to override") hints_string = "\nTry using %s." % ", ".join(hints) if hints else "" sys.stderr.write( err_prefix + (": %s" % error_message if error_message else "") + hints_string + "\n" ) sys.exit(1 if result is None else result) pcs-0.9.155/pcs/constraint.py000066400000000000000000001157111301012375000160010ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import sys import xml.dom.minidom from collections import defaultdict from xml.dom.minidom import parseString import pcs.cli.constraint_colocation.command as colocation_command import pcs.cli.constraint_order.command as order_command from pcs import ( rule as rule_utils, usage, utils, ) from pcs.cli import ( constraint_colocation, constraint_order, ) from pcs.cli.constraint_ticket import command as ticket_command from pcs.cli.common.errors import CmdLineInputError from pcs.lib.cib.constraint import resource_set from pcs.lib.cib.constraint.order import ATTRIB as order_attrib from pcs.lib.errors import LibraryError OPTIONS_ACTION = resource_set.ATTRIB["action"] DEFAULT_ACTION = "start" DEFAULT_ROLE = "Started" OPTIONS_SYMMETRICAL = order_attrib["symmetrical"] OPTIONS_KIND = order_attrib["kind"] def constraint_cmd(argv): lib = utils.get_library_wrapper() modificators = utils.get_modificators() if len(argv) == 0: argv = ["list"] sub_cmd = argv.pop(0) if (sub_cmd == "help"): usage.constraint(argv) elif (sub_cmd == "location"): if len (argv) == 0: sub_cmd2 = "show" else: sub_cmd2 = argv.pop(0) if (sub_cmd2 == "add"): location_add(argv) elif (sub_cmd2 in ["remove","delete"]): location_add(argv,True) elif (sub_cmd2 == "show"): location_show(argv) elif len(argv) >= 2: if argv[0] == "rule": location_rule([sub_cmd2] + argv) else: location_prefer([sub_cmd2] + argv) else: usage.constraint() sys.exit(1) elif (sub_cmd == "order"): if (len(argv) == 0): sub_cmd2 = "show" else: sub_cmd2 = argv.pop(0) if (sub_cmd2 == "set"): try: order_command.create_with_set(lib, argv, modificators) except CmdLineInputError as e: utils.exit_on_cmdline_input_errror(e, "constraint", 'order set') except LibraryError as e: utils.process_library_reports(e.args) elif (sub_cmd2 in ["remove","delete"]): order_rm(argv) elif (sub_cmd2 == "show"): order_command.show(lib, argv, modificators) else: order_start([sub_cmd2] + argv) elif sub_cmd == "ticket": usage_name = "ticket" try: command_map = { "set": ticket_command.create_with_set, "add": ticket_command.add, "remove": ticket_command.remove, "show": ticket_command.show, } sub_command = argv[0] if argv else "show" if sub_command not in command_map: raise CmdLineInputError() usage_name = "ticket "+sub_command command_map[sub_command](lib, argv[1:], modificators) except LibraryError as e: utils.process_library_reports(e.args) except CmdLineInputError as e: utils.exit_on_cmdline_input_errror(e, "constraint", usage_name) elif (sub_cmd == "colocation"): if (len(argv) == 0): sub_cmd2 = "show" else: sub_cmd2 = argv.pop(0) if (sub_cmd2 == "add"): colocation_add(argv) elif (sub_cmd2 in ["remove","delete"]): colocation_rm(argv) elif (sub_cmd2 == "set"): try: colocation_command.create_with_set(lib, argv, modificators) except LibraryError as e: utils.process_library_reports(e.args) except CmdLineInputError as e: utils.exit_on_cmdline_input_errror(e, "constraint", "colocation set") elif (sub_cmd2 == "show"): colocation_command.show(lib, argv, modificators) else: usage.constraint() sys.exit(1) elif (sub_cmd in ["remove","delete"]): constraint_rm(argv) elif (sub_cmd == "show" or sub_cmd == "list"): location_show(argv) order_command.show(lib, argv, modificators) colocation_command.show(lib, argv, modificators) ticket_command.show(lib, argv, modificators) elif (sub_cmd == "ref"): constraint_ref(argv) elif (sub_cmd == "rule"): constraint_rule(argv) else: usage.constraint() sys.exit(1) def colocation_rm(argv): elementFound = False if len(argv) < 2: usage.constraint() sys.exit(1) (dom,constraintsElement) = getCurrentConstraints() resource1 = argv[0] resource2 = argv[1] for co_loc in constraintsElement.getElementsByTagName('rsc_colocation')[:]: if co_loc.getAttribute("rsc") == resource1 and co_loc.getAttribute("with-rsc") == resource2: constraintsElement.removeChild(co_loc) elementFound = True if co_loc.getAttribute("rsc") == resource2 and co_loc.getAttribute("with-rsc") == resource1: constraintsElement.removeChild(co_loc) elementFound = True if elementFound == True: utils.replace_cib_configuration(dom) else: print("No matching resources found in ordering list") # When passed an array of arguments if the first argument doesn't have an '=' # then it's the score, otherwise they're all arguments # Return a tuple with the score and array of name,value pairs def parse_score_options(argv): if len(argv) == 0: return "INFINITY",[] arg_array = [] first = argv[0] if first.find('=') != -1: score = "INFINITY" else: score = argv.pop(0) for arg in argv: args = arg.split('=') if (len(args) != 2): continue arg_array.append(args) return (score, arg_array) # There are two acceptable syntaxes # Deprecated - colocation add [score] [options] # Supported - colocation add [role] with [role] [score] [options] def colocation_add(argv): if len(argv) < 2: usage.constraint() sys.exit(1) role1 = "" role2 = "" if len(argv) > 2: if not utils.is_score_or_opt(argv[2]): if argv[2] == "with": role1 = argv.pop(0).lower().capitalize() resource1 = argv.pop(0) else: resource1 = argv.pop(0) argv.pop(0) # Pop 'with' if len(argv) == 1: resource2 = argv.pop(0) else: if utils.is_score_or_opt(argv[1]): resource2 = argv.pop(0) else: role2 = argv.pop(0).lower().capitalize() resource2 = argv.pop(0) else: resource1 = argv.pop(0) resource2 = argv.pop(0) else: resource1 = argv.pop(0) resource2 = argv.pop(0) cib_dom = utils.get_cib_dom() resource_valid, resource_error, correct_id \ = utils.validate_constraint_resource(cib_dom, resource1) if "--autocorrect" in utils.pcs_options and correct_id: resource1 = correct_id elif not resource_valid: utils.err(resource_error) resource_valid, resource_error, correct_id \ = utils.validate_constraint_resource(cib_dom, resource2) if "--autocorrect" in utils.pcs_options and correct_id: resource2 = correct_id elif not resource_valid: utils.err(resource_error) score,nv_pairs = parse_score_options(argv) id_in_nvpairs = None for name, value in nv_pairs: if name == "id": id_valid, id_error = utils.validate_xml_id(value, 'constraint id') if not id_valid: utils.err(id_error) if utils.does_id_exist(cib_dom, value): utils.err( "id '%s' is already in use, please specify another one" % value ) id_in_nvpairs = True if not id_in_nvpairs: nv_pairs.append(( "id", utils.find_unique_id( cib_dom, "colocation-%s-%s-%s" % (resource1, resource2, score) ) )) (dom,constraintsElement) = getCurrentConstraints(cib_dom) # If one role is specified, the other should default to "started" if role1 != "" and role2 == "": role2 = DEFAULT_ROLE if role2 != "" and role1 == "": role1 = DEFAULT_ROLE element = dom.createElement("rsc_colocation") element.setAttribute("rsc",resource1) element.setAttribute("with-rsc",resource2) element.setAttribute("score",score) if role1 != "": element.setAttribute("rsc-role", role1) if role2 != "": element.setAttribute("with-rsc-role", role2) for nv_pair in nv_pairs: element.setAttribute(nv_pair[0], nv_pair[1]) if "--force" not in utils.pcs_options: duplicates = colocation_find_duplicates(constraintsElement, element) if duplicates: utils.err( "duplicate constraint already exists, use --force to override\n" + "\n".join([ " " + constraint_colocation.console_report.constraint_plain( {"options": dict(dup.attributes.items())}, True ) for dup in duplicates ]) ) constraintsElement.appendChild(element) utils.replace_cib_configuration(dom) def colocation_find_duplicates(dom, constraint_el): def normalize(const_el): return ( const_el.getAttribute("rsc"), const_el.getAttribute("with-rsc"), const_el.getAttribute("rsc-role").capitalize() or DEFAULT_ROLE, const_el.getAttribute("with-rsc-role").capitalize() or DEFAULT_ROLE, ) normalized_el = normalize(constraint_el) return [ other_el for other_el in dom.getElementsByTagName("rsc_colocation") if not other_el.getElementsByTagName("resource_set") and constraint_el is not other_el and normalized_el == normalize(other_el) ] def order_rm(argv): if len(argv) == 0: usage.constraint() sys.exit(1) elementFound = False (dom,constraintsElement) = getCurrentConstraints() for resource in argv: for ord_loc in constraintsElement.getElementsByTagName('rsc_order')[:]: if ord_loc.getAttribute("first") == resource or ord_loc.getAttribute("then") == resource: constraintsElement.removeChild(ord_loc) elementFound = True resource_refs_to_remove = [] for ord_set in constraintsElement.getElementsByTagName('resource_ref'): if ord_set.getAttribute("id") == resource: resource_refs_to_remove.append(ord_set) elementFound = True for res_ref in resource_refs_to_remove: res_set = res_ref.parentNode res_order = res_set.parentNode res_ref.parentNode.removeChild(res_ref) if len(res_set.getElementsByTagName('resource_ref')) <= 0: res_set.parentNode.removeChild(res_set) if len(res_order.getElementsByTagName('resource_set')) <= 0: res_order.parentNode.removeChild(res_order) if elementFound == True: utils.replace_cib_configuration(dom) else: utils.err("No matching resources found in ordering list") def order_start(argv): if len(argv) < 3: usage.constraint() sys.exit(1) first_action = DEFAULT_ACTION then_action = DEFAULT_ACTION action = argv[0] if action in OPTIONS_ACTION: first_action = action argv.pop(0) resource1 = argv.pop(0) if argv.pop(0) != "then": usage.constraint() sys.exit(1) if len(argv) == 0: usage.constraint() sys.exit(1) action = argv[0] if action in OPTIONS_ACTION: then_action = action argv.pop(0) if len(argv) == 0: usage.constraint() sys.exit(1) resource2 = argv.pop(0) order_options = [] if len(argv) != 0: order_options = order_options + argv[:] order_options.append("first-action="+first_action) order_options.append("then-action="+then_action) order_add([resource1, resource2] + order_options) def order_add(argv,returnElementOnly=False): if len(argv) < 2: usage.constraint() sys.exit(1) resource1 = argv.pop(0) resource2 = argv.pop(0) cib_dom = utils.get_cib_dom() resource_valid, resource_error, correct_id \ = utils.validate_constraint_resource(cib_dom, resource1) if "--autocorrect" in utils.pcs_options and correct_id: resource1 = correct_id elif not resource_valid: utils.err(resource_error) resource_valid, resource_error, correct_id \ = utils.validate_constraint_resource(cib_dom, resource2) if "--autocorrect" in utils.pcs_options and correct_id: resource2 = correct_id elif not resource_valid: utils.err(resource_error) order_options = [] id_specified = False sym = None for arg in argv: if arg == "symmetrical": sym = "true" elif arg == "nonsymmetrical": sym = "false" elif "=" in arg: name, value = arg.split("=", 1) if name == "id": id_valid, id_error = utils.validate_xml_id(value, 'constraint id') if not id_valid: utils.err(id_error) if utils.does_id_exist(cib_dom, value): utils.err( "id '%s' is already in use, please specify another one" % value ) id_specified = True order_options.append((name, value)) elif name == "symmetrical": if value.lower() in OPTIONS_SYMMETRICAL: sym = value.lower() else: utils.err( "invalid symmetrical value '%s', allowed values are: %s" % (value, ", ".join(OPTIONS_SYMMETRICAL)) ) else: order_options.append((name, value)) if sym: order_options.append(("symmetrical", sym)) options = "" if order_options: options = " (Options: %s)" % " ".join([ "%s=%s" % (name, value) for name, value in order_options if name not in ("kind", "score") ]) scorekind = "kind: Mandatory" id_suffix = "mandatory" for opt in order_options: if opt[0] == "score": scorekind = "score: " + opt[1] id_suffix = opt[1] break if opt[0] == "kind": scorekind = "kind: " + opt[1] id_suffix = opt[1] break if not id_specified: order_id = "order-" + resource1 + "-" + resource2 + "-" + id_suffix order_id = utils.find_unique_id(cib_dom, order_id) order_options.append(("id", order_id)) (dom,constraintsElement) = getCurrentConstraints() element = dom.createElement("rsc_order") element.setAttribute("first",resource1) element.setAttribute("then",resource2) for order_opt in order_options: element.setAttribute(order_opt[0], order_opt[1]) constraintsElement.appendChild(element) if "--force" not in utils.pcs_options: duplicates = order_find_duplicates(constraintsElement, element) if duplicates: utils.err( "duplicate constraint already exists, use --force to override\n" + "\n".join([ " " + constraint_order.console_report.constraint_plain( {"options": dict(dup.attributes.items())}, True ) for dup in duplicates ]) ) print( "Adding " + resource1 + " " + resource2 + " ("+scorekind+")" + options ) if returnElementOnly == False: utils.replace_cib_configuration(dom) else: return element.toxml() def order_find_duplicates(dom, constraint_el): def normalize(constraint_el): return ( constraint_el.getAttribute("first"), constraint_el.getAttribute("then"), constraint_el.getAttribute("first-action").lower() or DEFAULT_ACTION, constraint_el.getAttribute("then-action").lower() or DEFAULT_ACTION, ) normalized_el = normalize(constraint_el) return [ other_el for other_el in dom.getElementsByTagName("rsc_order") if not other_el.getElementsByTagName("resource_set") and constraint_el is not other_el and normalized_el == normalize(other_el) ] # Show the currently configured location constraints by node or resource def location_show(argv): if (len(argv) != 0 and argv[0] == "nodes"): byNode = True showDetail = False elif "--full" in utils.pcs_options: byNode = False showDetail = True else: byNode = False showDetail = False if len(argv) > 1: valid_noderes = argv[1:] else: valid_noderes = [] (dummy_dom,constraintsElement) = getCurrentConstraints() nodehashon = {} nodehashoff = {} rschashon = {} rschashoff = {} ruleshash = defaultdict(list) all_loc_constraints = constraintsElement.getElementsByTagName('rsc_location') print("Location Constraints:") for rsc_loc in all_loc_constraints: lc_node = rsc_loc.getAttribute("node") lc_rsc = rsc_loc.getAttribute("rsc") lc_id = rsc_loc.getAttribute("id") lc_score = rsc_loc.getAttribute("score") lc_role = rsc_loc.getAttribute("role") lc_name = "Resource: " + lc_rsc lc_resource_discovery = rsc_loc.getAttribute("resource-discovery") for child in rsc_loc.childNodes: if child.nodeType == child.ELEMENT_NODE and child.tagName == "rule": ruleshash[lc_name].append(child) # NEED TO FIX FOR GROUP LOCATION CONSTRAINTS (where there are children of # rsc_location) if lc_score == "": lc_score = "0" if lc_score == "INFINITY": positive = True elif lc_score == "-INFINITY": positive = False elif int(lc_score) >= 0: positive = True else: positive = False if positive == True: nodeshash = nodehashon rschash = rschashon else: nodeshash = nodehashoff rschash = rschashoff if lc_node in nodeshash: nodeshash[lc_node].append((lc_id,lc_rsc,lc_score, lc_role, lc_resource_discovery)) else: nodeshash[lc_node] = [(lc_id, lc_rsc,lc_score, lc_role, lc_resource_discovery)] if lc_rsc in rschash: rschash[lc_rsc].append((lc_id,lc_node,lc_score, lc_role, lc_resource_discovery)) else: rschash[lc_rsc] = [(lc_id,lc_node,lc_score, lc_role, lc_resource_discovery)] nodelist = list(set(list(nodehashon.keys()) + list(nodehashoff.keys()))) rsclist = list(set(list(rschashon.keys()) + list(rschashoff.keys()))) if byNode == True: for node in nodelist: if len(valid_noderes) != 0: if node not in valid_noderes: continue print(" Node: " + node) nodehash_label = ( (nodehashon, " Allowed to run:"), (nodehashoff, " Not allowed to run:") ) for nodehash, label in nodehash_label: if node in nodehash: print(label) for options in nodehash[node]: line_parts = [ " " + options[1] + " (" + options[0] + ")", ] if options[3]: line_parts.append("(role: {0})".format(options[3])) if options[4]: line_parts.append( "(resource-discovery={0})".format(options[4]) ) line_parts.append("Score: " + options[2]) print(" ".join(line_parts)) show_location_rules(ruleshash,showDetail) else: rsclist.sort() for rsc in rsclist: if len(valid_noderes) != 0: if rsc not in valid_noderes: continue print(" Resource: " + rsc) rschash_label = ( (rschashon, " Enabled on:"), (rschashoff, " Disabled on:"), ) for rschash, label in rschash_label: if rsc in rschash: for options in rschash[rsc]: if not options[1]: continue line_parts = [ label, options[1], "(score:{0})".format(options[2]), ] if options[3]: line_parts.append("(role: {0})".format(options[3])) if options[4]: line_parts.append( "(resource-discovery={0})".format(options[4]) ) if showDetail: line_parts.append("(id:{0})".format(options[0])) print(" ".join(line_parts)) miniruleshash={} miniruleshash["Resource: " + rsc] = ruleshash["Resource: " + rsc] show_location_rules(miniruleshash,showDetail, True) def show_location_rules(ruleshash,showDetail,noheader=False): constraint_options = {} for rsc in ruleshash: constrainthash= defaultdict(list) if not noheader: print(" " + rsc) for rule in ruleshash[rsc]: constraint_id = rule.parentNode.getAttribute("id") constrainthash[constraint_id].append(rule) constraint_options[constraint_id] = [] if rule.parentNode.getAttribute("resource-discovery"): constraint_options[constraint_id].append("resource-discovery=%s" % rule.parentNode.getAttribute("resource-discovery")) for constraint_id in sorted(constrainthash.keys()): if constraint_id in constraint_options and len(constraint_options[constraint_id]) > 0: constraint_option_info = " (" + " ".join(constraint_options[constraint_id]) + ")" else: constraint_option_info = "" print(" Constraint: " + constraint_id + constraint_option_info) for rule in constrainthash[constraint_id]: print(rule_utils.ExportDetailed().get_string( rule, showDetail, " " )) def location_prefer(argv): rsc = argv.pop(0) prefer_option = argv.pop(0) if prefer_option == "prefers": prefer = True elif prefer_option == "avoids": prefer = False else: usage.constraint() sys.exit(1) for nodeconf in argv: nodeconf_a = nodeconf.split("=",1) if len(nodeconf_a) == 1: node = nodeconf_a[0] if prefer: score = "INFINITY" else: score = "-INFINITY" else: score = nodeconf_a[1] if not utils.is_score(score): utils.err("invalid score '%s', use integer or INFINITY or -INFINITY" % score) if not prefer: if score[0] == "-": score = score[1:] else: score = "-" + score node = nodeconf_a[0] location_add(["location-" +rsc+"-"+node+"-"+score,rsc,node,score]) def location_add(argv,rm=False): if len(argv) < 4 and (rm == False or len(argv) < 1): usage.constraint() sys.exit(1) constraint_id = argv.pop(0) # If we're removing, we only care about the id if (rm == True): resource_name = "" node = "" score = "" else: id_valid, id_error = utils.validate_xml_id(constraint_id, 'constraint id') if not id_valid: utils.err(id_error) resource_name = argv.pop(0) node = argv.pop(0) score = argv.pop(0) options = [] # For now we only allow setting resource-discovery if len(argv) > 0: for arg in argv: if '=' in arg: options.append(arg.split('=',1)) else: print("Error: bad option '%s'" % arg) usage.constraint(["location add"]) sys.exit(1) if options[-1][0] != "resource-discovery" and "--force" not in utils.pcs_options: utils.err("bad option '%s', use --force to override" % options[-1][0]) resource_valid, resource_error, correct_id \ = utils.validate_constraint_resource( utils.get_cib_dom(), resource_name ) if "--autocorrect" in utils.pcs_options and correct_id: resource_name = correct_id elif not resource_valid: utils.err(resource_error) if not utils.is_score(score): utils.err("invalid score '%s', use integer or INFINITY or -INFINITY" % score) # Verify current constraint doesn't already exist # If it does we replace it with the new constraint (dom,constraintsElement) = getCurrentConstraints() elementsToRemove = [] # If the id matches, or the rsc & node match, then we replace/remove for rsc_loc in constraintsElement.getElementsByTagName('rsc_location'): if (constraint_id == rsc_loc.getAttribute("id")) or \ (rsc_loc.getAttribute("rsc") == resource_name and \ rsc_loc.getAttribute("node") == node and not rm): elementsToRemove.append(rsc_loc) for etr in elementsToRemove: constraintsElement.removeChild(etr) if (rm == True and len(elementsToRemove) == 0): utils.err("resource location id: " + constraint_id + " not found.") if (not rm): element = dom.createElement("rsc_location") element.setAttribute("id",constraint_id) element.setAttribute("rsc",resource_name) element.setAttribute("node",node) element.setAttribute("score",score) for option in options: element.setAttribute(option[0], option[1]) constraintsElement.appendChild(element) utils.replace_cib_configuration(dom) def location_rule(argv): if len(argv) < 3: usage.constraint(["location", "rule"]) sys.exit(1) res_name = argv.pop(0) resource_valid, resource_error, correct_id \ = utils.validate_constraint_resource(utils.get_cib_dom(), res_name) if "--autocorrect" in utils.pcs_options and correct_id: res_name = correct_id elif not resource_valid: utils.err(resource_error) argv.pop(0) # pop "rule" options, rule_argv = rule_utils.parse_argv(argv, {"constraint-id": None, "resource-discovery": None,}) # If resource-discovery is specified, we use it with the rsc_location # element not the rule if "resource-discovery" in options and options["resource-discovery"]: utils.checkAndUpgradeCIB(2,2,0) cib, constraints = getCurrentConstraints(utils.get_cib_dom()) lc = cib.createElement("rsc_location") lc.setAttribute("resource-discovery", options.pop("resource-discovery")) else: cib, constraints = getCurrentConstraints(utils.get_cib_dom()) lc = cib.createElement("rsc_location") constraints.appendChild(lc) if options.get("constraint-id"): id_valid, id_error = utils.validate_xml_id( options["constraint-id"], 'constraint id' ) if not id_valid: utils.err(id_error) if utils.does_id_exist(cib, options["constraint-id"]): utils.err( "id '%s' is already in use, please specify another one" % options["constraint-id"] ) lc.setAttribute("id", options["constraint-id"]) del options["constraint-id"] else: lc.setAttribute("id", utils.find_unique_id(cib, "location-" + res_name)) lc.setAttribute("rsc", res_name) rule_utils.dom_rule_add(lc, options, rule_argv) location_rule_check_duplicates(constraints, lc) utils.replace_cib_configuration(cib) def location_rule_check_duplicates(dom, constraint_el): if "--force" not in utils.pcs_options: duplicates = location_rule_find_duplicates(dom, constraint_el) if duplicates: lines = [] for dup in duplicates: lines.append(" Constraint: %s" % dup.getAttribute("id")) for dup_rule in utils.dom_get_children_by_tag_name(dup, "rule"): lines.append(rule_utils.ExportDetailed().get_string( dup_rule, True, " " )) utils.err( "duplicate constraint already exists, use --force to override\n" + "\n".join(lines) ) def location_rule_find_duplicates(dom, constraint_el): def normalize(constraint_el): return ( constraint_el.getAttribute("rsc"), [ rule_utils.ExportAsExpression().get_string(rule_el, True) for rule_el in constraint_el.getElementsByTagName("rule") ] ) normalized_el = normalize(constraint_el) return [ other_el for other_el in dom.getElementsByTagName("rsc_location") if other_el.getElementsByTagName("rule") and constraint_el is not other_el and normalized_el == normalize(other_el) ] # Grabs the current constraints and returns the dom and constraint element def getCurrentConstraints(passed_dom=None): if passed_dom: dom = passed_dom else: current_constraints_xml = utils.get_cib_xpath('//constraints') if current_constraints_xml == "": utils.err("unable to process cib") # Verify current constraint doesn't already exist # If it does we replace it with the new constraint dom = parseString(current_constraints_xml) constraintsElement = dom.getElementsByTagName('constraints')[0] return (dom, constraintsElement) # If returnStatus is set, then we don't error out, we just print the error # and return false def constraint_rm(argv,returnStatus=False, constraintsElement=None, passed_dom=None): if len(argv) < 1: usage.constraint() sys.exit(1) bad_constraint = False if len(argv) != 1: for arg in argv: if not constraint_rm([arg],True, passed_dom=passed_dom): bad_constraint = True if bad_constraint: sys.exit(1) return else: c_id = argv.pop(0) elementFound = False if not constraintsElement: (dom, constraintsElement) = getCurrentConstraints(passed_dom) use_cibadmin = True else: use_cibadmin = False for co in constraintsElement.childNodes[:]: if co.nodeType != xml.dom.Node.ELEMENT_NODE: continue if co.getAttribute("id") == c_id: constraintsElement.removeChild(co) elementFound = True if not elementFound: for rule in constraintsElement.getElementsByTagName("rule")[:]: if rule.getAttribute("id") == c_id: elementFound = True parent = rule.parentNode parent.removeChild(rule) if len(parent.getElementsByTagName("rule")) == 0: parent.parentNode.removeChild(parent) if elementFound == True: if passed_dom: return dom if use_cibadmin: utils.replace_cib_configuration(dom) if returnStatus: return True else: utils.err("Unable to find constraint - '%s'" % c_id, False) if returnStatus: return False sys.exit(1) def constraint_ref(argv): if len(argv) == 0: usage.constraint() sys.exit(1) for arg in argv: print("Resource: %s" % arg) constraints,set_constraints = find_constraints_containing(arg) if len(constraints) == 0 and len(set_constraints) == 0: print(" No Matches.") else: for constraint in constraints: print(" " + constraint) for constraint in sorted(set_constraints): print(" " + constraint) def remove_constraints_containing(resource_id,output=False,constraints_element = None, passed_dom=None): constraints,set_constraints = find_constraints_containing(resource_id, passed_dom) for c in constraints: if output == True: print("Removing Constraint - " + c) if constraints_element != None: constraint_rm([c], True, constraints_element, passed_dom=passed_dom) else: constraint_rm([c], passed_dom=passed_dom) if len(set_constraints) != 0: (dom, constraintsElement) = getCurrentConstraints(passed_dom) for c in constraintsElement.getElementsByTagName("resource_ref")[:]: # If resource id is in a set, remove it from the set, if the set # is empty, then we remove the set, if the parent of the set # is empty then we remove it if c.getAttribute("id") == resource_id: pn = c.parentNode pn.removeChild(c) if output == True: print("Removing %s from set %s" % (resource_id,pn.getAttribute("id"))) if pn.getElementsByTagName("resource_ref").length == 0: print("Removing set %s" % pn.getAttribute("id")) pn2 = pn.parentNode pn2.removeChild(pn) if pn2.getElementsByTagName("resource_set").length == 0: pn2.parentNode.removeChild(pn2) print("Removing constraint %s" % pn2.getAttribute("id")) if passed_dom: return dom utils.replace_cib_configuration(dom) def find_constraints_containing(resource_id, passed_dom=None): if passed_dom: dom = passed_dom else: dom = utils.get_cib_dom() constraints_found = [] set_constraints = [] resources = dom.getElementsByTagName("primitive") resource_match = None for res in resources: if res.getAttribute("id") == resource_id: resource_match = res break if resource_match: if resource_match.parentNode.tagName == "master" or resource_match.parentNode.tagName == "clone": constraints_found,set_constraints = find_constraints_containing(resource_match.parentNode.getAttribute("id"), dom) constraints = dom.getElementsByTagName("constraints") if len(constraints) == 0: return [],[] else: constraints = constraints[0] myConstraints = constraints.getElementsByTagName("rsc_colocation") myConstraints += constraints.getElementsByTagName("rsc_location") myConstraints += constraints.getElementsByTagName("rsc_order") myConstraints += constraints.getElementsByTagName("rsc_ticket") attr_to_match = ["rsc", "first", "then", "with-rsc", "first", "then"] for c in myConstraints: for attr in attr_to_match: if c.getAttribute(attr) == resource_id: constraints_found.append(c.getAttribute("id")) break setConstraints = constraints.getElementsByTagName("resource_ref") for c in setConstraints: if c.getAttribute("id") == resource_id: set_constraints.append(c.parentNode.parentNode.getAttribute("id")) # Remove duplicates set_constraints = list(set(set_constraints)) return constraints_found,set_constraints def remove_constraints_containing_node(dom, node, output=False): for constraint in find_constraints_containing_node(dom, node): if output: print("Removing Constraint - %s" % constraint.getAttribute("id")) constraint.parentNode.removeChild(constraint) return dom def find_constraints_containing_node(dom, node): return [ constraint for constraint in dom.getElementsByTagName("rsc_location") if constraint.getAttribute("node") == node ] # Re-assign any constraints referencing a resource to its parent (a clone # or master) def constraint_resource_update(old_id, passed_dom=None): dom = utils.get_cib_dom() if passed_dom is None else passed_dom new_id = None clone_ms_parent = utils.dom_get_resource_clone_ms_parent(dom, old_id) if clone_ms_parent: new_id = clone_ms_parent.getAttribute("id") if new_id: constraints = dom.getElementsByTagName("rsc_location") constraints += dom.getElementsByTagName("rsc_order") constraints += dom.getElementsByTagName("rsc_colocation") attrs_to_update=["rsc","first","then", "with-rsc"] for constraint in constraints: for attr in attrs_to_update: if constraint.getAttribute(attr) == old_id: constraint.setAttribute(attr, new_id) if passed_dom is None: utils.replace_cib_configuration(dom) if passed_dom: return dom def constraint_rule(argv): if len(argv) < 2: usage.constraint("rule") sys.exit(1) found = False command = argv.pop(0) constraint_id = None if command == "add": constraint_id = argv.pop(0) cib = utils.get_cib_dom() constraint = utils.dom_get_element_with_id( cib.getElementsByTagName("constraints")[0], "rsc_location", constraint_id ) if not constraint: utils.err("Unable to find constraint: " + constraint_id) options, rule_argv = rule_utils.parse_argv(argv) rule_utils.dom_rule_add(constraint, options, rule_argv) location_rule_check_duplicates(cib, constraint) utils.replace_cib_configuration(cib) elif command in ["remove","delete"]: cib = utils.get_cib_etree() temp_id = argv.pop(0) constraints = cib.find('.//constraints') loc_cons = cib.findall(str('.//rsc_location')) for loc_con in loc_cons: for rule in loc_con: if rule.get("id") == temp_id: if len(loc_con) > 1: print("Removing Rule: {0}".format(rule.get("id"))) loc_con.remove(rule) found = True break else: print( "Removing Constraint: {0}".format(loc_con.get("id")) ) constraints.remove(loc_con) found = True break if found == True: break if found: utils.replace_cib_configuration(cib) else: utils.err("unable to find rule with id: %s" % temp_id) else: usage.constraint("rule") sys.exit(1) pcs-0.9.155/pcs/lib/000077500000000000000000000000001301012375000140035ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/__init__.py000066400000000000000000000000001301012375000161020ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/booth/000077500000000000000000000000001301012375000151165ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/booth/__init__.py000066400000000000000000000000001301012375000172150ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/booth/config_exchange.py000066400000000000000000000011731301012375000206010ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.lib.booth.config_structure import ConfigItem def to_exchange_format(booth_configuration): return [ { "key": item.key, "value": item.value, "details": to_exchange_format(item.details), } for item in booth_configuration ] def from_exchange_format(exchange_format): return [ ConfigItem( item["key"], item["value"], from_exchange_format(item["details"]), ) for item in exchange_format ] pcs-0.9.155/pcs/lib/booth/config_files.py000066400000000000000000000057451301012375000201320ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os import binascii from pcs.common import report_codes, env_file_role_codes as file_roles from pcs.common.tools import format_environment_error from pcs.lib import reports as lib_reports from pcs.lib.booth import reports from pcs.lib.errors import ReportItemSeverity from pcs.settings import booth_config_dir as BOOTH_CONFIG_DIR def generate_key(): return binascii.hexlify(os.urandom(32)) def get_all_configs_file_names(): """ Returns list of all file names ending with '.conf' in booth configuration directory. """ if not os.path.isdir(BOOTH_CONFIG_DIR): return [] return [ file_name for file_name in os.listdir(BOOTH_CONFIG_DIR) if file_name.endswith(".conf") and len(file_name) > len(".conf") and os.path.isfile(os.path.join(BOOTH_CONFIG_DIR, file_name)) ] def _read_config(file_name): """ Read specified booth config from default booth config directory. file_name -- string, name of file """ with open(os.path.join(BOOTH_CONFIG_DIR, file_name), "r") as file: return file.read() def read_configs(reporter, skip_wrong_config=False): """ Returns content of all configs present on local system in dictionary, where key is name of config and value is its content. reporter -- report processor skip_wrong_config -- if True skip local configs that are unreadable """ report_list = [] output = {} for file_name in get_all_configs_file_names(): try: output[file_name] = _read_config(file_name) except EnvironmentError: report_list.append(reports.booth_config_read_error( file_name, ( ReportItemSeverity.WARNING if skip_wrong_config else ReportItemSeverity.ERROR ), ( None if skip_wrong_config else report_codes.SKIP_UNREADABLE_CONFIG ) )) reporter.process_list(report_list) return output def read_authfile(reporter, path): """ Returns content of specified authfile as bytes. None if file is not in default booth directory or there was some IO error. reporter -- report processor path -- path to the authfile to be read """ if not path: return None if os.path.dirname(os.path.abspath(path)) != BOOTH_CONFIG_DIR: reporter.process(reports.booth_unsupported_file_location(path)) return None try: with open(path, "rb") as file: return file.read() except EnvironmentError as e: reporter.process(lib_reports.file_io_error( file_roles.BOOTH_KEY, path, reason=format_environment_error(e), operation="read", severity=ReportItemSeverity.WARNING )) return None pcs-0.9.155/pcs/lib/booth/config_parser.py000066400000000000000000000054441301012375000203200ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import re from pcs.lib.booth import config_structure, reports from pcs.lib.errors import LibraryError class InvalidLines(Exception): pass def parse(content): try: return organize_lines(parse_to_raw_lines(content)) except InvalidLines as e: raise LibraryError( reports.booth_config_unexpected_lines(e.args[0]) ) def build(config_line_list): newline = [""] return "\n".join(build_to_lines(config_line_list) + newline) def build_to_lines(config_line_list, deep=0): line_list = [] for key, value, details in config_line_list: line_value = value if key != "ticket" else '"{0}"'.format(value) line_list.append("{0}{1} = {2}".format(" "*deep, key, line_value)) if details: line_list.extend(build_to_lines(details, deep+1)) return line_list def organize_lines(raw_line_list): #Decision: Global key is moved up when is below ticket. Alternative is move #it below all ticket details. But it is confusing. global_section = [] ticket_section = [] current_ticket = None for key, value in raw_line_list: if key == "ticket": current_ticket = config_structure.ConfigItem(key, value) ticket_section.append(current_ticket) elif key in config_structure.GLOBAL_KEYS or not current_ticket: global_section.append(config_structure.ConfigItem(key, value)) else: current_ticket.details.append( config_structure.ConfigItem(key, value) ) return global_section + ticket_section def search_with_multiple_re(re_object_list, string): """ return MatchObject of first matching regular expression object or None list re_object_list contains regular expresssion objects (products of re.compile) """ for expression in re_object_list: match = expression.search(string) if match: return match return None def parse_to_raw_lines(config_content): keyword_part = r"^(?P[a-zA-Z0-9_-]+)\s*=\s*" expression_list = [re.compile(pattern.format(keyword_part)) for pattern in [ r"""{0}(?P[^'"]+)$""", r"""{0}'(?P[^']*)'\s*(#.*)?$""", r"""{0}"(?P[^"]*)"\s*(#.*)?$""", ]] line_list = [] invalid_line_list = [] for line in config_content.splitlines(): line = line.strip() match = search_with_multiple_re(expression_list, line) if match: line_list.append((match.group("key"), match.group("value"))) elif line and not line.startswith("#"): invalid_line_list.append(line) if invalid_line_list: raise InvalidLines(invalid_line_list) return line_list pcs-0.9.155/pcs/lib/booth/config_structure.py000066400000000000000000000113711301012375000210600ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import re import pcs.lib.reports as common_reports from pcs.lib.booth import reports from pcs.lib.errors import LibraryError, ReportItemSeverity as severities from pcs.common import report_codes from collections import namedtuple GLOBAL_KEYS = ( "transport", "port", "name", "authfile", "maxtimeskew", "site", "arbitrator", "site-user", "site-group", "arbitrator-user", "arbitrator-group", "debug", "ticket", ) TICKET_KEYS = ( "acquire-after", "attr-prereq", "before-acquire-handler", "expire", "renewal-freq", "retries", "timeout", "weights", ) class ConfigItem(namedtuple("ConfigItem", "key value details")): def __new__(cls, key, value, details=None): details = details if details else [] return super(ConfigItem, cls).__new__(cls, key, value, details) def validate_peers(site_list, arbitrator_list): report = [] if len(site_list) < 2: report.append(reports.booth_lack_of_sites(site_list)) peer_list = site_list + arbitrator_list if len(peer_list) % 2 == 0: report.append(reports.booth_even_peers_num(len(peer_list))) address_set = set() duplicate_addresses = set() for address in peer_list: if address in address_set: duplicate_addresses.add(address) else: address_set.add(address) if duplicate_addresses: report.append(reports.booth_address_duplication(duplicate_addresses)) if report: raise LibraryError(*report) def take_peers(booth_configuration): return ( pick_list_by_key(booth_configuration, "site"), pick_list_by_key(booth_configuration, "arbitrator"), ) def pick_list_by_key(booth_configuration, key): return [item.value for item in booth_configuration if item.key == key] def remove_ticket(booth_configuration, ticket_name): validate_ticket_exists(booth_configuration, ticket_name) return [ config_item for config_item in booth_configuration if config_item.key != "ticket" or config_item.value != ticket_name ] def add_ticket( report_processor, booth_configuration, ticket_name, options, allow_unknown_options ): validate_ticket_name(ticket_name) validate_ticket_unique(booth_configuration, ticket_name) validate_ticket_options(report_processor, options, allow_unknown_options) return booth_configuration + [ ConfigItem("ticket", ticket_name, [ ConfigItem(key, value) for key, value in options.items() ]) ] def validate_ticket_exists(booth_configuration, ticket_name): if not ticket_exists(booth_configuration, ticket_name): raise LibraryError(reports.booth_ticket_does_not_exist(ticket_name)) def validate_ticket_unique(booth_configuration, ticket_name): if ticket_exists(booth_configuration, ticket_name): raise LibraryError(reports.booth_ticket_duplicate(ticket_name)) def validate_ticket_options(report_processor, options, allow_unknown_options): reports = [] for key in sorted(options): if key in GLOBAL_KEYS: reports.append( common_reports.invalid_option(key, TICKET_KEYS, "booth ticket") ) elif key not in TICKET_KEYS: reports.append( common_reports.invalid_option( key, TICKET_KEYS, "booth ticket", severity=( severities.WARNING if allow_unknown_options else severities.ERROR ), forceable=( None if allow_unknown_options else report_codes.FORCE_OPTIONS ), ) ) if not options[key].strip(): reports.append(common_reports.invalid_option_value( key, options[key], "no-empty", )) report_processor.process_list(reports) def ticket_exists(booth_configuration, ticket_name): return any( value for key, value, _ in booth_configuration if key == "ticket" and value == ticket_name ) def validate_ticket_name(ticket_name): if not re.compile(r"^[\w-]+$").search(ticket_name): raise LibraryError(reports.booth_ticket_name_invalid(ticket_name)) def set_authfile(booth_configuration, auth_file): return [ConfigItem("authfile", auth_file)] + [ config_item for config_item in booth_configuration if config_item.key != "authfile" ] def get_authfile(booth_configuration): for key, value, _ in reversed(booth_configuration): if key == "authfile": return value return None pcs-0.9.155/pcs/lib/booth/env.py000066400000000000000000000110511301012375000162560ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os import pwd import grp from pcs import settings from pcs.common import env_file_role_codes from pcs.common.tools import format_environment_error from pcs.lib import reports as common_reports from pcs.lib.booth import reports from pcs.lib.env_file import GhostFile, RealFile from pcs.lib.errors import LibraryError from pcs.settings import booth_config_dir as BOOTH_CONFIG_DIR def get_booth_env_file_name(name, extension): report_list = [] if "/" in name: report_list.append( reports.booth_invalid_name(name, "contains illegal character '/'") ) if report_list: raise LibraryError(*report_list) return "{0}.{1}".format(os.path.join(BOOTH_CONFIG_DIR, name), extension) def get_config_file_name(name): return get_booth_env_file_name(name, "conf") def get_key_path(name): return get_booth_env_file_name(name, "key") def report_keyfile_io_error(file_path, operation, e): return LibraryError(common_reports.file_io_error( file_role=env_file_role_codes.BOOTH_KEY, file_path=file_path, operation=operation, reason=format_environment_error(e) )) def set_keyfile_access(file_path): #shutil.chown is not in python2 try: uid = pwd.getpwnam(settings.pacemaker_uname).pw_uid except KeyError: raise LibraryError(common_reports.unable_to_determine_user_uid( settings.pacemaker_uname )) try: gid = grp.getgrnam(settings.pacemaker_gname).gr_gid except KeyError: raise LibraryError(common_reports.unable_to_determine_group_gid( settings.pacemaker_gname )) try: os.chown(file_path, uid, gid) except EnvironmentError as e: raise report_keyfile_io_error(file_path, "chown", e) try: os.chmod(file_path, 0o600) except EnvironmentError as e: raise report_keyfile_io_error(file_path, "chmod", e) class BoothEnv(object): def __init__(self, report_processor, env_data): self.__report_processor = report_processor self.__name = env_data["name"] if "config_file" in env_data: self.__config = GhostFile( file_role=env_file_role_codes.BOOTH_CONFIG, content=env_data["config_file"]["content"] ) self.__key_path = env_data["key_path"] self.__key = GhostFile( file_role=env_file_role_codes.BOOTH_KEY, content=env_data["key_file"]["content"] ) else: self.__config = RealFile( file_role=env_file_role_codes.BOOTH_CONFIG, file_path=get_config_file_name(env_data["name"]), ) self.__set_key_path(get_key_path(env_data["name"])) def __set_key_path(self, path): self.__key_path = path self.__key = RealFile( file_role=env_file_role_codes.BOOTH_KEY, file_path=path, ) def command_expect_live_env(self): if not self.__config.is_live: raise LibraryError(common_reports.live_environment_required([ "--booth-conf", "--booth-key", ])) def set_key_path(self, path): if not self.__config.is_live: raise AssertionError( "Set path of keyfile is supported only in live environment" ) self.__set_key_path(path) @property def name(self): return self.__name @property def key_path(self): return self.__key_path def get_config_content(self): return self.__config.read() def create_config(self, content, can_overwrite_existing=False): self.__config.assert_no_conflict_with_existing( self.__report_processor, can_overwrite_existing ) self.__config.write(content) def create_key(self, key_content, can_overwrite_existing=False): self.__key.assert_no_conflict_with_existing( self.__report_processor, can_overwrite_existing ) self.__key.write(key_content, set_keyfile_access, is_binary=True) def push_config(self, content): self.__config.write(content) def remove_key(self): self.__key.remove(silence_no_existence=True) def remove_config(self): self.__config.remove() def export(self): return {} if self.__config.is_live else { "config_file": self.__config.export(), "key_file": self.__key.export(), } pcs-0.9.155/pcs/lib/booth/reports.py000066400000000000000000000232731301012375000171750ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.common import report_codes from pcs.lib.errors import ReportItem, ReportItemSeverity def booth_lack_of_sites(site_list): """ Less than 2 booth sites entered. But it does not make sense. list site_list contains currently entered sites """ return ReportItem.error( report_codes.BOOTH_LACK_OF_SITES, info={ "sites": site_list, } ) def booth_even_peers_num(number): """ Booth requires odd number of peers. But even number of peers was entered. integer number determines how many peers was entered """ return ReportItem.error( report_codes.BOOTH_EVEN_PEERS_NUM, info={ "number": number, } ) def booth_address_duplication(duplicate_addresses): """ Address of each peer must unique. But address duplication appeared. set duplicate_addresses contains addreses entered multiple times """ return ReportItem.error( report_codes.BOOTH_ADDRESS_DUPLICATION, info={ "addresses": duplicate_addresses, } ) def booth_config_unexpected_lines(line_list): """ Booth config have defined structure. But line out of structure definition appeared. list line_list contains lines out of defined structure """ return ReportItem.error( report_codes.BOOTH_CONFIG_UNEXPECTED_LINES, info={ "line_list": line_list, } ) def booth_invalid_name(name, reason): """ Booth instance name have rules. For example it cannot contain illegal characters like '/'. But some of rules was violated. string name is entered booth instance name """ return ReportItem.error( report_codes.BOOTH_INVALID_NAME, info={ "name": name, "reason": reason, } ) def booth_ticket_name_invalid(ticket_name): """ Name of booth ticket may consists of alphanumeric characters or dash. Entered ticket name violating this rule. string ticket_name is entered booth ticket name """ return ReportItem.error( report_codes.BOOTH_TICKET_NAME_INVALID, info={ "ticket_name": ticket_name, } ) def booth_ticket_duplicate(ticket_name): """ Each booth ticket name must be uniqe. But duplicate booth ticket name was entered. string ticket_name is entered booth ticket name """ return ReportItem.error( report_codes.BOOTH_TICKET_DUPLICATE, info={ "ticket_name": ticket_name, } ) def booth_ticket_does_not_exist(ticket_name): """ Some operations (like ticket remove) expect the ticket name in booth configuration. But the ticket name not found in booth configuration. string ticket_name is entered booth ticket name """ return ReportItem.error( report_codes.BOOTH_TICKET_DOES_NOT_EXIST, info={ "ticket_name": ticket_name, } ) def booth_already_in_cib(name): """ Each booth instance should be in a cib once maximally. Existence of booth instance in cib detected during creating new one. string name is booth instance name """ return ReportItem.error( report_codes.BOOTH_ALREADY_IN_CIB, info={ "name": name, } ) def booth_not_exists_in_cib(name): """ Remove booth instance from cib required. But no such instance found in cib. string name is booth instance name """ return ReportItem.error( report_codes.BOOTH_NOT_EXISTS_IN_CIB, info={ "name": name, } ) def booth_config_is_used(name, detail=""): """ Booth config use detected during destroy request. string name is booth instance name string detail provide more details (for example booth instance is used as cluster resource or is started/enabled under systemd) """ return ReportItem.error( report_codes.BOOTH_CONFIG_IS_USED, info={ "name": name, "detail": detail, "detail_string": " {0}".format(detail) if detail else "", } ) def booth_multiple_times_in_cib( name, severity=ReportItemSeverity.ERROR ): """ Each booth instance should be in a cib once maximally. But multiple occurences detected. For example during remove booth instance from cib. Notify user about this fact is required. When operation is forced user should be notified about multiple occurences. string name is booth instance name ReportItemSeverity severit should be ERROR or WARNING (depends on context) is flag for next report processing Because of severity coupling with ReportItem is it specified here. """ return ReportItem( report_codes.BOOTH_MULTIPLE_TIMES_IN_CIB, severity, info={ "name": name, }, forceable=report_codes.FORCE_BOOTH_REMOVE_FROM_CIB if severity == ReportItemSeverity.ERROR else None ) def booth_config_distribution_started(): """ booth configuration is about to be sent to nodes """ return ReportItem.info( report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED, ) def booth_config_accepted_by_node(node=None, name_list=None): """ Booth config has been saved on specified node. node -- name of node name_list -- list of names of booth instance """ return ReportItem.info( report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE, info={ "node": node, "name_list": name_list } ) def booth_config_distribution_node_error(node, reason, name=None): """ Saving booth config failed on specified node. node -- node name reason -- reason of failure name -- name of booth instance """ return ReportItem.error( report_codes.BOOTH_CONFIG_DISTRIBUTION_NODE_ERROR, info={ "node": node, "name": name, "reason": reason } ) def booth_config_read_error( name, severity=ReportItemSeverity.ERROR, forceable=None ): """ Unable to read from specified booth instance config. name -- name of booth instance severity -- severity of report item forceable -- is this report item forceable? by what category? """ return ReportItem( report_codes.BOOTH_CONFIG_READ_ERROR, severity, info={"name": name}, forceable=forceable ) def booth_fetching_config_from_node_started(node, config=None): """ fetching of booth config from specified node started node -- node from which config is fetching config -- config name """ return ReportItem.info( report_codes.BOOTH_FETCHING_CONFIG_FROM_NODE, info={ "node": node, "config": config, } ) def booth_unsupported_file_location(file): """ location of booth configuration file (config, authfile) file is not supported (not in /etc/booth/) file -- file path """ return ReportItem.warning( report_codes.BOOTH_UNSUPORTED_FILE_LOCATION, info={"file": file} ) def booth_daemon_status_error(reason): """ Unable to get status of booth daemon because of error. reason -- reason """ return ReportItem.error( report_codes.BOOTH_DAEMON_STATUS_ERROR, info={"reason": reason} ) def booth_tickets_status_error(reason=None): """ Unable to get status of booth tickets because of error. reason -- reason """ return ReportItem.error( report_codes.BOOTH_TICKET_STATUS_ERROR, info={ "reason": reason, } ) def booth_peers_status_error(reason=None): """ Unable to get status of booth peers because of error. reason -- reason """ return ReportItem.error( report_codes.BOOTH_PEERS_STATUS_ERROR, info={ "reason": reason, } ) def booth_cannot_determine_local_site_ip(): """ Some booth operations are performed on specific site and requires to specify site ip. When site specification omitted pcs can try determine local ip. But determine local site ip failed. """ return ReportItem.error( report_codes.BOOTH_CANNOT_DETERMINE_LOCAL_SITE_IP, info={} ) def booth_ticket_operation_failed(operation, reason, site_ip, ticket_name): """ Pcs uses external booth tools for some ticket_name operations. For example grand and revoke. But the external command failed. string operatin determine what was intended perform with ticket_name string reason is taken from external booth command string site_ip specifiy what site had to run the command string ticket_name specify with which ticket had to run the command """ return ReportItem.error( report_codes.BOOTH_TICKET_OPERATION_FAILED, info={ "operation": operation, "reason": reason, "site_ip": site_ip, "ticket_name": ticket_name, } ) def booth_skipping_config(config_file, reason): """ Warning about skipping booth config file. config_file -- file name of config which is skipped reason -- reason """ return ReportItem.warning( report_codes.BOOTH_SKIPPING_CONFIG, info={ "config_file": config_file, "reason": reason, } ) def booth_cannot_identify_keyfile(severity=ReportItemSeverity.ERROR): return ReportItem( report_codes.BOOTH_CANNOT_IDENTIFY_KEYFILE, severity, info={}, forceable=report_codes.FORCE_BOOTH_DESTROY if severity == ReportItemSeverity.ERROR else None ) pcs-0.9.155/pcs/lib/booth/resource.py000066400000000000000000000056721301012375000173310ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.lib.cib.tools import find_unique_id def create_resource_id(resources_section, name, suffix): return find_unique_id( resources_section.getroottree(), "booth-{0}-{1}".format(name, suffix) ) def get_creator(resource_create, resource_remove=None): #TODO resource_create is provisional hack until resources are not moved to #lib def create_booth_in_cluster(ip, booth_config_file_path, create_id): ip_id = create_id("ip") booth_id = create_id("service") group_id = create_id("group") resource_create( ra_id=ip_id, ra_type="ocf:heartbeat:IPaddr2", ra_values=["ip={0}".format(ip)], op_values=[], meta_values=[], clone_opts=[], group=group_id, ) try: resource_create( ra_id=booth_id, ra_type="ocf:pacemaker:booth-site", ra_values=["config={0}".format(booth_config_file_path)], op_values=[], meta_values=[], clone_opts=[], group=group_id, ) except SystemExit: resource_remove(ip_id) return create_booth_in_cluster def is_ip_resource(resource_element): return resource_element.attrib["type"] == "IPaddr2" def find_grouped_ip_element_to_remove(booth_element): if booth_element.getparent().tag != "group": return None group = booth_element.getparent() if len(group) != 2: #when something else in group, ip is not for remove return None for element in group: if is_ip_resource(element): return element return None def get_remover(resource_remove): def remove_from_cluster(booth_element_list): for element in booth_element_list: ip_resource_to_remove = find_grouped_ip_element_to_remove(element) if ip_resource_to_remove is not None: resource_remove(ip_resource_to_remove.attrib["id"]) resource_remove(element.attrib["id"]) return remove_from_cluster def find_for_config(resources_section, booth_config_file_path): return resources_section.xpath((""" .//primitive[ @type="booth-site" and instance_attributes[nvpair[@name="config" and @value="{0}"]] ] """).format(booth_config_file_path)) def find_bound_ip(resources_section, booth_config_file_path): return resources_section.xpath((""" .//group[ primitive[ @type="booth-site" and instance_attributes[ nvpair[@name="config" and @value="{0}"] ] ] ] /primitive[@type="IPaddr2"] /instance_attributes /nvpair[@name="ip"] /@value """).format(booth_config_file_path)) pcs-0.9.155/pcs/lib/booth/status.py000066400000000000000000000025301301012375000170130ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs import settings from pcs.common.tools import join_multilines from pcs.lib.booth import reports from pcs.lib.errors import LibraryError def get_daemon_status(runner, name=None): cmd = [settings.booth_binary, "status"] if name: cmd += ["-c", name] stdout, stderr, return_value = runner.run(cmd) # 7 means that there is no booth instance running if return_value not in [0, 7]: raise LibraryError( reports.booth_daemon_status_error(join_multilines([stderr, stdout])) ) return stdout def get_tickets_status(runner, name=None): cmd = [settings.booth_binary, "list"] if name: cmd += ["-c", name] stdout, stderr, return_value = runner.run(cmd) if return_value != 0: raise LibraryError( reports.booth_tickets_status_error( join_multilines([stderr, stdout]) ) ) return stdout def get_peers_status(runner, name=None): cmd = [settings.booth_binary, "peers"] if name: cmd += ["-c", name] stdout, stderr, return_value = runner.run(cmd) if return_value != 0: raise LibraryError( reports.booth_peers_status_error(join_multilines([stderr, stdout])) ) return stdout pcs-0.9.155/pcs/lib/booth/sync.py000066400000000000000000000145621301012375000164540ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os import json import base64 from pcs.common import report_codes from pcs.lib import reports as lib_reports from pcs.lib.errors import LibraryError, ReportItemSeverity as Severities from pcs.lib.external import ( NodeCommunicator, NodeCommunicationException, node_communicator_exception_to_report_item, parallel_nodes_communication_helper, ) from pcs.lib.booth import ( config_files as booth_conf, config_structure, config_parser, reports, ) def _set_config_on_node( communicator, reporter, node, name, config_data, authfile=None, authfile_data=None ): """ Set booth config for instance 'name' on specified node. communicator -- NodeCommunicator reporter -- report processor node -- NodeAddresses name -- name of booth instance config_data -- booth config as string authfile -- path to authfile authfile_data -- authfile content as bytes """ data = { "config": { "name": "{0}.conf".format(name), "data": config_data } } if authfile is not None and authfile_data is not None: data["authfile"] = { "name": os.path.basename(authfile), "data": base64.b64encode(authfile_data).decode("utf-8") } communicator.call_node( node, "remote/booth_set_config", NodeCommunicator.format_data_dict([("data_json", json.dumps(data))]) ) reporter.process(reports.booth_config_accepted_by_node(node.label, [name])) def send_config_to_all_nodes( communicator, reporter, node_list, name, config_data, authfile=None, authfile_data=None, skip_offline=False ): """ Send config_data of specified booth instance from local node to all nodes in node_list. communicator -- NodeCommunicator reporter -- report processor node_list -- NodeAddressesList name -- name of booth instance config_data -- config_data content as string authfile -- path to authfile authfile_data -- content of authfile as bytes skip_offline -- if True offline nodes will be skipped """ reporter.process(reports.booth_config_distribution_started()) parallel_nodes_communication_helper( _set_config_on_node, [ ( [ communicator, reporter, node, name, config_data, authfile, authfile_data ], {} ) for node in node_list ], reporter, skip_offline ) def send_all_config_to_node( communicator, reporter, node, rewrite_existing=False, skip_wrong_config=False ): """ Send all booth configs from default booth config directory and theri authfiles to specified node. communicator -- NodeCommunicator reporter -- report processor node -- NodeAddress rewrite_existing -- if True rewrite existing file skip_wrong_config -- if True skip local configs that are unreadable """ config_dict = booth_conf.read_configs(reporter, skip_wrong_config) if not config_dict: return reporter.process(reports.booth_config_distribution_started()) file_list = [] for config, config_data in sorted(config_dict.items()): try: authfile_path = config_structure.get_authfile( config_parser.parse(config_data) ) file_list.append({ "name": config, "data": config_data, "is_authfile": False }) if authfile_path: content = booth_conf.read_authfile(reporter, authfile_path) if not content: continue file_list.append({ "name": os.path.basename(authfile_path), "data": base64.b64encode(content).decode("utf-8"), "is_authfile": True }) except LibraryError: reporter.process(reports.booth_skipping_config( config, "unable to parse config" )) data = [("data_json", json.dumps(file_list))] if rewrite_existing: data.append(("rewrite_existing", "1")) try: response = json.loads(communicator.call_node( node, "remote/booth_save_files", NodeCommunicator.format_data_dict(data) )) report_list = [] for file in response["existing"]: report_list.append(lib_reports.file_already_exists( None, file, Severities.WARNING if rewrite_existing else Severities.ERROR, ( None if rewrite_existing else report_codes.FORCE_FILE_OVERWRITE ), node.label )) for file, reason in response["failed"].items(): report_list.append(reports.booth_config_distribution_node_error( node.label, reason, file )) reporter.process_list(report_list) reporter.process( reports.booth_config_accepted_by_node(node.label, response["saved"]) ) except NodeCommunicationException as e: raise LibraryError(node_communicator_exception_to_report_item(e)) except (KeyError, ValueError): raise LibraryError(lib_reports.invalid_response_format(node.label)) def pull_config_from_node(communicator, node, name): """ Get config of specified booth instance and its authfile if there is one from 'node'. It returns dictionary with format: { "config": { "name": , "data": }, "authfile": { "name": , "data": } communicator -- NodeCommunicator node -- NodeAddresses name -- name of booth instance """ try: return json.loads(communicator.call_node( node, "remote/booth_get_config", NodeCommunicator.format_data_dict([("name", name)]) )) except NodeCommunicationException as e: raise LibraryError(node_communicator_exception_to_report_item(e)) except ValueError: raise LibraryError(lib_reports.invalid_response_format(node.label)) pcs-0.9.155/pcs/lib/booth/test/000077500000000000000000000000001301012375000160755ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/booth/test/__init__.py000066400000000000000000000000001301012375000201740ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/booth/test/test_config_exchange.py000066400000000000000000000046701301012375000226240ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.lib.booth import config_structure, config_exchange class FromExchangeFormatTest(TestCase): def test_convert_all_supported_items(self): self.assertEqual( [ config_structure.ConfigItem("authfile", "/path/to/auth.file"), config_structure.ConfigItem("site", "1.1.1.1"), config_structure.ConfigItem("site", "2.2.2.2"), config_structure.ConfigItem("arbitrator", "3.3.3.3"), config_structure.ConfigItem("ticket", "TA"), config_structure.ConfigItem("ticket", "TB", [ config_structure.ConfigItem("expire", "10") ]), ], config_exchange.from_exchange_format([ {"key": "authfile","value": "/path/to/auth.file","details": []}, {"key": "site", "value": "1.1.1.1", "details": []}, {"key": "site", "value": "2.2.2.2", "details": []}, {"key": "arbitrator", "value": "3.3.3.3", "details": []}, {"key": "ticket", "value": "TA", "details": []}, {"key": "ticket", "value": "TB", "details": [ {"key": "expire", "value": "10", "details": []} ]}, ]) ) class GetExchenageFormatTest(TestCase): def test_convert_parsed_config_to_exchange_format(self): self.assertEqual( [ {"key": "site", "value": "1.1.1.1", "details": []}, {"key": "site", "value": "2.2.2.2", "details": []}, {"key": "arbitrator", "value": "3.3.3.3", "details": []}, {"key": "ticket", "value": "TA", "details": []}, {"key": "ticket", "value": "TB", "details": [ {"key": "timeout", "value": "10", "details": []} ]}, ], config_exchange.to_exchange_format([ config_structure.ConfigItem("site", "1.1.1.1"), config_structure.ConfigItem("site", "2.2.2.2"), config_structure.ConfigItem("arbitrator", "3.3.3.3"), config_structure.ConfigItem("ticket", "TA"), config_structure.ConfigItem("ticket", "TB", [ config_structure.ConfigItem("timeout", "10") ]), ]) ) pcs-0.9.155/pcs/lib/booth/test/test_config_files.py000066400000000000000000000232021301012375000221340ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os.path from pcs.test.tools.pcs_unittest import TestCase from pcs.common import report_codes, env_file_role_codes as file_roles from pcs.lib.booth import config_files from pcs.lib.errors import ReportItemSeverity as severities from pcs.settings import booth_config_dir as BOOTH_CONFIG_DIR from pcs.test.tools.assertions import assert_raise_library_error, assert_report_item_list_equal from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.test.tools.misc import create_patcher from pcs.test.tools.pcs_unittest import mock patch_config_files = create_patcher("pcs.lib.booth.config_files") @mock.patch("os.path.isdir") @mock.patch("os.listdir") @mock.patch("os.path.isfile") class GetAllConfigsFileNamesTest(TestCase): def test_booth_config_dir_is_no_dir( self, mock_is_file, mock_listdir, mock_isdir ): mock_isdir.return_value = False self.assertEqual([], config_files.get_all_configs_file_names()) mock_isdir.assert_called_once_with(BOOTH_CONFIG_DIR) self.assertEqual(0, mock_is_file.call_count) self.assertEqual(0, mock_listdir.call_count) def test_success(self, mock_is_file, mock_listdir, mock_isdir): def mock_is_file_fn(file_name): if file_name in [ os.path.join(BOOTH_CONFIG_DIR, name) for name in ("dir.cong", "dir") ]: return False elif file_name in [ os.path.join(BOOTH_CONFIG_DIR, name) for name in ( "name1", "name2.conf", "name.conf.conf", ".conf", "name3.conf" ) ]: return True else: raise AssertionError("unexpected input") mock_isdir.return_value = True mock_is_file.side_effect = mock_is_file_fn mock_listdir.return_value = [ "name1", "name2.conf", "name.conf.conf", ".conf", "name3.conf", "dir.cong", "dir" ] self.assertEqual( ["name2.conf", "name.conf.conf", "name3.conf"], config_files.get_all_configs_file_names() ) mock_listdir.assert_called_once_with(BOOTH_CONFIG_DIR) class ReadConfigTest(TestCase): def test_success(self): self.maxDiff = None mock_open = mock.mock_open(read_data="config content") with patch_config_files("open", mock_open, create=True): self.assertEqual( "config content", config_files._read_config("my-file.conf") ) self.assertEqual( [ mock.call(os.path.join(BOOTH_CONFIG_DIR, "my-file.conf"), "r"), mock.call().__enter__(), mock.call().read(), mock.call().__exit__(None, None, None) ], mock_open.mock_calls ) @patch_config_files("_read_config") @patch_config_files("get_all_configs_file_names") class ReadConfigsTest(TestCase): def setUp(self): self.mock_reporter = MockLibraryReportProcessor() def test_success(self, mock_get_configs, mock_read): def _mock_read_cfg(file): if file == "name1.conf": return "config1" elif file == "name2.conf": return "config2" elif file == "name3.conf": return "config3" else: raise AssertionError("unexpected input: {0}".format(file)) mock_get_configs.return_value = [ "name1.conf", "name2.conf", "name3.conf" ] mock_read.side_effect = _mock_read_cfg self.assertEqual( { "name1.conf": "config1", "name2.conf": "config2", "name3.conf": "config3" }, config_files.read_configs(self.mock_reporter) ) mock_get_configs.assert_called_once_with() self.assertEqual(3, mock_read.call_count) mock_read.assert_has_calls([ mock.call("name1.conf"), mock.call("name2.conf"), mock.call("name3.conf") ]) self.assertEqual(0, len(self.mock_reporter.report_item_list)) def test_skip_failed(self, mock_get_configs, mock_read): def _mock_read_cfg(file): if file in ["name1.conf", "name3.conf"]: raise EnvironmentError() elif file == "name2.conf": return "config2" else: raise AssertionError("unexpected input: {0}".format(file)) mock_get_configs.return_value = [ "name1.conf", "name2.conf", "name3.conf" ] mock_read.side_effect = _mock_read_cfg self.assertEqual( {"name2.conf": "config2"}, config_files.read_configs(self.mock_reporter, True) ) mock_get_configs.assert_called_once_with() self.assertEqual(3, mock_read.call_count) mock_read.assert_has_calls([ mock.call("name1.conf"), mock.call("name2.conf"), mock.call("name3.conf") ]) assert_report_item_list_equal( self.mock_reporter.report_item_list, [ ( severities.WARNING, report_codes.BOOTH_CONFIG_READ_ERROR, {"name": "name1.conf"} ), ( severities.WARNING, report_codes.BOOTH_CONFIG_READ_ERROR, {"name": "name3.conf"} ) ] ) def test_do_not_skip_failed(self, mock_get_configs, mock_read): def _mock_read_cfg(file): if file in ["name1.conf", "name3.conf"]: raise EnvironmentError() elif file == "name2.conf": return "config2" else: raise AssertionError("unexpected input: {0}".format(file)) mock_get_configs.return_value = [ "name1.conf", "name2.conf", "name3.conf" ] mock_read.side_effect = _mock_read_cfg assert_raise_library_error( lambda: config_files.read_configs(self.mock_reporter), ( severities.ERROR, report_codes.BOOTH_CONFIG_READ_ERROR, {"name": "name1.conf"}, report_codes.SKIP_UNREADABLE_CONFIG ), ( severities.ERROR, report_codes.BOOTH_CONFIG_READ_ERROR, {"name": "name3.conf"}, report_codes.SKIP_UNREADABLE_CONFIG ) ) mock_get_configs.assert_called_once_with() self.assertEqual(3, mock_read.call_count) mock_read.assert_has_calls([ mock.call("name1.conf"), mock.call("name2.conf"), mock.call("name3.conf") ]) self.assertEqual(2, len(self.mock_reporter.report_item_list)) class ReadAuthfileTest(TestCase): def setUp(self): self.mock_reporter = MockLibraryReportProcessor() self.maxDiff = None def test_success(self): path = os.path.join(BOOTH_CONFIG_DIR, "file.key") mock_open = mock.mock_open(read_data="key") with patch_config_files("open", mock_open, create=True): self.assertEqual( "key", config_files.read_authfile(self.mock_reporter, path) ) self.assertEqual( [ mock.call(path, "rb"), mock.call().__enter__(), mock.call().read(), mock.call().__exit__(None, None, None) ], mock_open.mock_calls ) self.assertEqual(0, len(self.mock_reporter.report_item_list)) def test_path_none(self): self.assertTrue( config_files.read_authfile(self.mock_reporter, None) is None ) self.assertEqual(0, len(self.mock_reporter.report_item_list)) def test_invalid_path(self): path = "/not/etc/booth/booth.key" self.assertTrue( config_files.read_authfile(self.mock_reporter, path) is None ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [( severities.WARNING, report_codes.BOOTH_UNSUPORTED_FILE_LOCATION, {"file": path} )] ) def test_not_abs_path(self): path = "/etc/booth/../booth.key" self.assertTrue( config_files.read_authfile(self.mock_reporter, path) is None ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [( severities.WARNING, report_codes.BOOTH_UNSUPORTED_FILE_LOCATION, {"file": path} )] ) @patch_config_files("format_environment_error", return_value="reason") def test_read_failure(self, _): path = os.path.join(BOOTH_CONFIG_DIR, "file.key") mock_open = mock.mock_open() mock_open().read.side_effect = EnvironmentError() with patch_config_files("open", mock_open, create=True): return_value = config_files.read_authfile(self.mock_reporter, path) self.assertTrue(return_value is None) assert_report_item_list_equal( self.mock_reporter.report_item_list, [( severities.WARNING, report_codes.FILE_IO_ERROR, { "file_role": file_roles.BOOTH_KEY, "file_path": path, "reason": "reason", "operation": "read", } )] ) pcs-0.9.155/pcs/lib/booth/test/test_config_parser.py000066400000000000000000000132661301012375000223370ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.common import report_codes from pcs.lib.booth import config_parser from pcs.lib.booth.config_structure import ConfigItem from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import assert_raise_library_error from pcs.test.tools.pcs_unittest import TestCase class BuildTest(TestCase): def test_build_file_content_from_parsed_structure(self): self.assertEqual( "\n".join([ "authfile = /path/to/auth.file", "site = 1.1.1.1", "site = 2.2.2.2", "arbitrator = 3.3.3.3", 'ticket = "TA"', 'ticket = "TB"', " timeout = 10", "", #newline at the end ]), config_parser.build([ ConfigItem("authfile", "/path/to/auth.file"), ConfigItem("site", "1.1.1.1"), ConfigItem("site", "2.2.2.2"), ConfigItem("arbitrator", "3.3.3.3"), ConfigItem("ticket", "TA"), ConfigItem("ticket", "TB", [ ConfigItem("timeout", "10") ]), ]) ) class OrganizeLinesTest(TestCase): def test_move_non_ticket_config_keys_above_tickets(self): self.assertEqual( [ ConfigItem("site", "1.1.1.1"), ConfigItem('site', '2.2.2.2'), ConfigItem('arbitrator', '3.3.3.3'), ConfigItem("ticket", "TA"), ], config_parser.organize_lines([ ("site", "1.1.1.1"), ("ticket", "TA"), ('site', '2.2.2.2'), ('arbitrator', '3.3.3.3'), ]) ) def test_use_ticket_key_as_ticket_detail(self): self.maxDiff = None self.assertEqual( [ ConfigItem("site", "1.1.1.1"), ConfigItem('expire', '300'), ConfigItem('site', '2.2.2.2'), ConfigItem('arbitrator', '3.3.3.3'), ConfigItem("ticket", "TA", [ ConfigItem("timeout", "10"), ConfigItem('--nonexistent', 'value'), ConfigItem("expire", "300"), ]), ConfigItem("ticket", "TB", [ ConfigItem("timeout", "20"), ConfigItem("renewal-freq", "40"), ]), ], config_parser.organize_lines([ ("site", "1.1.1.1"), ("expire", "300"), # out of ticket content is kept global ("ticket", "TA"), ("site", "2.2.2.2"), # move to global ("timeout", "10"), ("--nonexistent", "value"), # no global is kept under ticket ("expire", "300"), ("ticket", "TB"), ('arbitrator', '3.3.3.3'), ("timeout", "20"), ("renewal-freq", "40"), ]) ) class ParseRawLinesTest(TestCase): def test_parse_simple_correct_lines(self): self.assertEqual( [ ("site", "1.1.1.1"), ('site', '2.2.2.2'), ('arbitrator', '3.3.3.3'), ('syntactically_correct', 'nonsense'), ('line-with', 'hash#literal'), ], config_parser.parse_to_raw_lines("\n".join([ "site = 1.1.1.1", " site = 2.2.2.2 ", "arbitrator=3.3.3.3", "syntactically_correct = nonsense", "line-with = hash#literal", "", ])) ) def test_parse_lines_with_whole_line_comment(self): self.assertEqual( [("site", "1.1.1.1")], config_parser.parse_to_raw_lines("\n".join([ " # some comment", "site = 1.1.1.1", ])) ) def test_skip_empty_lines(self): self.assertEqual( [("site", "1.1.1.1")], config_parser.parse_to_raw_lines("\n".join([ " ", "site = 1.1.1.1", ])) ) def test_raises_when_unexpected_lines_appear(self): invalid_line_list = [ "first invalid line", "second = 'invalid line' something else #comment", "third = 'invalid line 'something#'#", ] line_list = ["site = 1.1.1.1"] + invalid_line_list with self.assertRaises(config_parser.InvalidLines) as context_manager: config_parser.parse_to_raw_lines("\n".join(line_list)) self.assertEqual(context_manager.exception.args[0], invalid_line_list) def test_parse_lines_finishing_with_comment(self): self.assertEqual( [("site", "1.1.1.1")], config_parser.parse_to_raw_lines("\n".join([ "site = '1.1.1.1' #comment", ])) ) class ParseTest(TestCase): def test_raises_when_invalid_lines_appear(self): invalid_line_list = [ "first invalid line", "second = 'invalid line' something else #comment" ] line_list = ["site = 1.1.1.1"] + invalid_line_list assert_raise_library_error( lambda: config_parser.parse("\n".join(line_list)) , ( severities.ERROR, report_codes.BOOTH_CONFIG_UNEXPECTED_LINES, { "line_list": invalid_line_list, }, ), ) def test_do_not_raises_when_no_invalid_liens_there(self): config_parser.parse("site = 1.1.1.1") pcs-0.9.155/pcs/lib/booth/test/test_config_structure.py000066400000000000000000000277051301012375000231060ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.common import report_codes from pcs.lib.booth import config_structure from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import ( assert_raise_library_error, assert_report_item_list_equal, ) from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.test.tools.pcs_unittest import mock class ValidateTicketExistsTest(TestCase): def test_raises_on_duplicate_ticket(self): assert_raise_library_error( lambda: config_structure.validate_ticket_exists( [config_structure.ConfigItem("ticket", "B")], "A" ), ( severities.ERROR, report_codes.BOOTH_TICKET_DOES_NOT_EXIST, { "ticket_name": "A", }, ), ) class ValidateTicketUniqueTest(TestCase): def test_raises_on_duplicate_ticket(self): assert_raise_library_error( lambda: config_structure.validate_ticket_unique( [config_structure.ConfigItem("ticket", "A")], "A" ), ( severities.ERROR, report_codes.BOOTH_TICKET_DUPLICATE, { "ticket_name": "A", }, ), ) def test_do_not_raises_when_no_duplicated_ticket(self): config_structure.validate_ticket_unique([], "A") class ValidateTicketOptionsTest(TestCase): def test_raises_on_invalid_options(self): report_processor = MockLibraryReportProcessor() expected_errors = [ ( severities.ERROR, report_codes.INVALID_OPTION, { "option_name": "site", "option_type": "booth ticket", "allowed": list(config_structure.TICKET_KEYS), }, ), ( severities.ERROR, report_codes.INVALID_OPTION, { "option_name": "port", "option_type": "booth ticket", "allowed": list(config_structure.TICKET_KEYS), }, ), ( severities.ERROR, report_codes.INVALID_OPTION_VALUE, { "option_name": "timeout", "option_value": " ", "allowed_values": "no-empty", }, ), ( severities.ERROR, report_codes.INVALID_OPTION, { "option_name": "unknown", "option_type": "booth ticket", "allowed": list(config_structure.TICKET_KEYS), }, report_codes.FORCE_OPTIONS ), ] assert_raise_library_error( lambda: config_structure.validate_ticket_options( report_processor, { "site": "a", "port": "b", "timeout": " ", "unknown": "c", }, allow_unknown_options=False, ), *expected_errors ) assert_report_item_list_equal( report_processor.report_item_list, expected_errors ) def test_unknown_options_are_forceable(self): report_processor = MockLibraryReportProcessor() expected_errors = [ ( severities.ERROR, report_codes.INVALID_OPTION, { "option_name": "site", "option_type": "booth ticket", "allowed": list(config_structure.TICKET_KEYS), }, ), ] assert_raise_library_error( lambda: config_structure.validate_ticket_options( report_processor, { "site": "a", "unknown": "c", }, allow_unknown_options=True, ), *expected_errors ) assert_report_item_list_equal( report_processor.report_item_list, expected_errors + [ ( severities.WARNING, report_codes.INVALID_OPTION, { "option_name": "unknown", "option_type": "booth ticket", "allowed": list(config_structure.TICKET_KEYS), }, ), ] ) def test_success_on_valid_options(self): report_processor = MockLibraryReportProcessor() config_structure.validate_ticket_options( report_processor, {"timeout": "10"}, allow_unknown_options=False, ) assert_report_item_list_equal(report_processor.report_item_list, []) class TicketExistsTest(TestCase): def test_returns_true_if_ticket_in_structure(self): self.assertTrue(config_structure.ticket_exists( [config_structure.ConfigItem("ticket", "A")], "A" )) def test_returns_false_if_ticket_in_structure(self): self.assertFalse(config_structure.ticket_exists( [config_structure.ConfigItem("ticket", "A")], "B" )) class ValidateTicketNameTest(TestCase): def test_accept_valid_ticket_name(self): config_structure.validate_ticket_name("abc") def test_refuse_bad_ticket_name(self): assert_raise_library_error( lambda: config_structure.validate_ticket_name("@ticket"), ( severities.ERROR, report_codes.BOOTH_TICKET_NAME_INVALID, { "ticket_name": "@ticket", }, ), ) class ValidatePeersTest(TestCase): def test_do_no_raises_on_correct_args(self): config_structure.validate_peers( site_list=["1.1.1.1", "2.2.2.2"], arbitrator_list=["3.3.3.3"] ) def test_refuse_less_than_2_sites(self): assert_raise_library_error( lambda: config_structure.validate_peers( site_list=["1.1.1.1"], arbitrator_list=["3.3.3.3", "4.4.4.4"] ), ( severities.ERROR, report_codes.BOOTH_LACK_OF_SITES, { "sites": ["1.1.1.1"], } ), ) def test_refuse_even_number_peers(self): assert_raise_library_error( lambda: config_structure.validate_peers( site_list=["1.1.1.1", "2.2.2.2"], arbitrator_list=[] ), ( severities.ERROR, report_codes.BOOTH_EVEN_PEERS_NUM, { "number": 2, } ), ) def test_refuse_address_duplication(self): assert_raise_library_error( lambda: config_structure.validate_peers( site_list=["1.1.1.1", "1.1.1.1", "1.1.1.1"], arbitrator_list=["3.3.3.3", "4.4.4.4"] ), ( severities.ERROR, report_codes.BOOTH_ADDRESS_DUPLICATION, { "addresses": set(["1.1.1.1"]), } ), ) def test_refuse_problem_combination(self): assert_raise_library_error( lambda: config_structure.validate_peers( site_list=["1.1.1.1"], arbitrator_list=["1.1.1.1"] ), ( severities.ERROR, report_codes.BOOTH_LACK_OF_SITES, { "sites": ["1.1.1.1"], } ), ( severities.ERROR, report_codes.BOOTH_EVEN_PEERS_NUM, { "number": 2, } ), ( severities.ERROR, report_codes.BOOTH_ADDRESS_DUPLICATION, { "addresses": set(["1.1.1.1"]), } ), ) class RemoveTicketTest(TestCase): @mock.patch("pcs.lib.booth.config_structure.validate_ticket_exists") def test_successfully_remove_ticket(self, mock_validate_ticket_exists): configuration = [ config_structure.ConfigItem("ticket", "some-ticket"), config_structure.ConfigItem("ticket", "deprecated-ticket"), ] self.assertEqual( config_structure.remove_ticket(configuration, "deprecated-ticket"), [ config_structure.ConfigItem("ticket", "some-ticket"), ] ) mock_validate_ticket_exists.assert_called_once_with( configuration, "deprecated-ticket" ) class AddTicketTest(TestCase): @mock.patch("pcs.lib.booth.config_structure.validate_ticket_options") @mock.patch("pcs.lib.booth.config_structure.validate_ticket_unique") @mock.patch("pcs.lib.booth.config_structure.validate_ticket_name") def test_successfully_add_ticket( self, mock_validate_name, mock_validate_uniq, mock_validate_options ): configuration = [ config_structure.ConfigItem("ticket", "some-ticket"), ] self.assertEqual( config_structure.add_ticket( None, configuration, "new-ticket", { "timeout": "10", }, allow_unknown_options=False, ), [ config_structure.ConfigItem("ticket", "some-ticket"), config_structure.ConfigItem("ticket", "new-ticket", [ config_structure.ConfigItem("timeout", "10"), ]), ], ) mock_validate_name.assert_called_once_with("new-ticket") mock_validate_uniq.assert_called_once_with(configuration, "new-ticket") mock_validate_options.assert_called_once_with( None, {"timeout": "10"}, False ) class SetAuthfileTest(TestCase): def test_add_authfile(self): self.assertEqual( [ config_structure.ConfigItem("authfile", "/path/to/auth.file"), config_structure.ConfigItem("site", "1.1.1.1"), ], config_structure.set_authfile( [ config_structure.ConfigItem("site", "1.1.1.1"), ], "/path/to/auth.file" ) ) def test_reset_authfile(self): self.assertEqual( [ config_structure.ConfigItem("authfile", "/path/to/auth.file"), config_structure.ConfigItem("site", "1.1.1.1"), ], config_structure.set_authfile( [ config_structure.ConfigItem("site", "1.1.1.1"), config_structure.ConfigItem("authfile", "/old/path/to/auth1.file"), config_structure.ConfigItem("authfile", "/old/path/to/auth2.file"), ], "/path/to/auth.file" ) ) class TakePeersTest(TestCase): def test_returns_site_list_and_arbitrators_list(self): self.assertEqual( ( ["1.1.1.1", "2.2.2.2", "3.3.3.3"], ["4.4.4.4", "5.5.5.5"] ), config_structure.take_peers( [ config_structure.ConfigItem("site", "1.1.1.1"), config_structure.ConfigItem("site", "2.2.2.2"), config_structure.ConfigItem("site", "3.3.3.3"), config_structure.ConfigItem("arbitrator", "4.4.4.4"), config_structure.ConfigItem("arbitrator", "5.5.5.5"), ], ) ) pcs-0.9.155/pcs/lib/booth/test/test_env.py000066400000000000000000000170601301012375000203020ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import grp import os import pwd from pcs.test.tools.pcs_unittest import TestCase from pcs import settings from pcs.common import report_codes from pcs.lib.booth import env from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import assert_raise_library_error from pcs.test.tools.misc import get_test_resource as rc, create_patcher from pcs.test.tools.pcs_unittest import mock patch_env = create_patcher("pcs.lib.booth.env") class GetConfigFileNameTest(TestCase): @patch_env("os.path.exists") def test_refuse_when_name_starts_with_slash(self, mock_path_exists): mock_path_exists.return_value = True assert_raise_library_error( lambda: env.get_config_file_name("/booth"), ( severities.ERROR, report_codes.BOOTH_INVALID_NAME, { "name": "/booth", "reason": "contains illegal character '/'", } ), ) class BoothEnvTest(TestCase): @patch_env("RealFile") def test_get_content_from_file(self, mock_real_file): mock_real_file.return_value = mock.MagicMock( read=mock.MagicMock(return_value="content") ) self.assertEqual( "content", env.BoothEnv("report processor", env_data={"name": "booth"}) .get_config_content() ) @patch_env("set_keyfile_access") @patch_env("RealFile") def test_create_config(self, mock_real_file, mock_set_keyfile_access): mock_file = mock.MagicMock( assert_no_conflict_with_existing=mock.MagicMock(), write=mock.MagicMock(), ) mock_real_file.return_value = mock_file env.BoothEnv( "report processor", env_data={"name": "booth"} ).create_config("a", can_overwrite_existing=True) self.assertEqual(mock_file.assert_no_conflict_with_existing.mock_calls,[ mock.call('report processor', True), ]) self.assertEqual(mock_file.write.mock_calls, [mock.call('a')]) @patch_env("RealFile") def test_push_config(self, mock_real_file): mock_file = mock.MagicMock( assert_no_conflict_with_existing=mock.MagicMock(), write=mock.MagicMock(), ) mock_real_file.return_value = mock_file env.BoothEnv( "report processor", env_data={"name": "booth"} ).push_config("a") mock_file.write.assert_called_once_with("a") def test_export_config_file_when_was_present_in_env_data(self): self.assertEqual( env.BoothEnv( "report processor", { "name": "booth-name", "config_file": { "content": "a\nb", }, "key_file": { "content": "secure", }, "key_path": "/path/to/file.key", } ).export(), { "config_file": { "content": "a\nb", "can_overwrite_existing_file": False, "no_existing_file_expected": False, "is_binary": False, }, "key_file": { "content": "secure", "can_overwrite_existing_file": False, "no_existing_file_expected": False, "is_binary": False, }, } ) def test_do_not_export_config_file_when_no_provided(self): self.assertEqual( env.BoothEnv("report processor", {"name": "booth"}).export(), {} ) class SetKeyfileAccessTest(TestCase): def test_set_desired_file_access(self): #setup file_path = rc("temp-keyfile") if os.path.exists(file_path): os.remove(file_path) with open(file_path, "w") as file: file.write("content") #check assumptions stat = os.stat(file_path) self.assertNotEqual('600', oct(stat.st_mode)[-3:]) current_user = pwd.getpwuid(os.getuid())[0] if current_user != settings.pacemaker_uname: file_user = pwd.getpwuid(stat.st_uid)[0] self.assertNotEqual(file_user, settings.pacemaker_uname) current_group = grp.getgrgid(os.getgid())[0] if current_group != settings.pacemaker_gname: file_group = grp.getgrgid(stat.st_gid)[0] self.assertNotEqual(file_group, settings.pacemaker_gname) #run tested method env.set_keyfile_access(file_path) #check stat = os.stat(file_path) self.assertEqual('600', oct(stat.st_mode)[-3:]) file_user = pwd.getpwuid(stat.st_uid)[0] self.assertEqual(file_user, settings.pacemaker_uname) file_group = grp.getgrgid(stat.st_gid)[0] self.assertEqual(file_group, settings.pacemaker_gname) @patch_env("pwd.getpwnam", mock.MagicMock(side_effect=KeyError)) @patch_env("settings.pacemaker_uname", "some-user") def test_raises_when_cannot_get_uid(self): assert_raise_library_error( lambda: env.set_keyfile_access("/booth"), ( severities.ERROR, report_codes.UNABLE_TO_DETERMINE_USER_UID, { "user": "some-user", } ), ) @patch_env("grp.getgrnam", mock.MagicMock(side_effect=KeyError)) @patch_env("pwd.getpwnam", mock.MagicMock()) @patch_env("settings.pacemaker_gname", "some-group") def test_raises_when_cannot_get_gid(self): assert_raise_library_error( lambda: env.set_keyfile_access("/booth"), ( severities.ERROR, report_codes.UNABLE_TO_DETERMINE_GROUP_GID, { "group": "some-group", } ), ) @patch_env("format_environment_error", mock.Mock(return_value="err")) @patch_env("os.chown", mock.MagicMock(side_effect=EnvironmentError())) @patch_env("grp.getgrnam", mock.MagicMock()) @patch_env("pwd.getpwnam", mock.MagicMock()) @patch_env("settings.pacemaker_gname", "some-group") def test_raises_when_cannot_chown(self): assert_raise_library_error( lambda: env.set_keyfile_access("/booth"), ( severities.ERROR, report_codes.FILE_IO_ERROR, { 'reason': 'err', 'file_role': u'BOOTH_KEY', 'file_path': '/booth', 'operation': u'chown', } ), ) @patch_env("format_environment_error", mock.Mock(return_value="err")) @patch_env("os.chmod", mock.MagicMock(side_effect=EnvironmentError())) @patch_env("os.chown", mock.MagicMock()) @patch_env("grp.getgrnam", mock.MagicMock()) @patch_env("pwd.getpwnam", mock.MagicMock()) @patch_env("settings.pacemaker_gname", "some-group") def test_raises_when_cannot_chmod(self): assert_raise_library_error( lambda: env.set_keyfile_access("/booth"), ( severities.ERROR, report_codes.FILE_IO_ERROR, { 'reason': 'err', 'file_role': u'BOOTH_KEY', 'file_path': '/booth', 'operation': u'chmod', } ), ) pcs-0.9.155/pcs/lib/booth/test/test_resource.py000066400000000000000000000143361301012375000213440ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from lxml import etree import pcs.lib.booth.resource as booth_resource from pcs.test.tools.pcs_unittest import mock from pcs.test.tools.misc import get_test_resource as rc def fixture_resources_with_booth(booth_config_file_path): return etree.fromstring(''' '''.format(booth_config_file_path)) def fixture_booth_element(id, booth_config_file_path): return etree.fromstring(''' '''.format(id, booth_config_file_path)) def fixture_ip_element(id, ip=""): return etree.fromstring(''' '''.format(id, ip)) class CreateResourceIdTest(TestCase): @mock.patch("pcs.lib.booth.resource.find_unique_id") def test_return_new_uinq_id(self, mock_find_unique_id): resources_section = etree.fromstring('''''') mock_find_unique_id.side_effect = ( lambda resources_section, id: "{0}-n".format(id) ) self.assertEqual( "booth-some-name-ip-n", booth_resource.create_resource_id( resources_section, "some-name", "ip" ) ) class FindBoothResourceElementsTest(TestCase): def test_returns_empty_list_when_no_matching_booth_element(self): self.assertEqual([], booth_resource.find_for_config( fixture_resources_with_booth("/ANOTHER/PATH/TO/CONF"), "/PATH/TO/CONF" )) def test_returns_all_found_resource_elements(self): resources = etree.fromstring('') first = fixture_booth_element("first", "/PATH/TO/CONF") second = fixture_booth_element("second", "/ANOTHER/PATH/TO/CONF") third = fixture_booth_element("third", "/PATH/TO/CONF") for element in [first, second,third]: resources.append(element) self.assertEqual( [first, third], booth_resource.find_for_config( resources, "/PATH/TO/CONF" ) ) class RemoveFromClusterTest(TestCase): def call(self, element_list): mock_resource_remove = mock.Mock() booth_resource.get_remover(mock_resource_remove)(element_list) return mock_resource_remove def test_remove_ip_when_is_only_booth_sibling_in_group(self): group = etree.fromstring(''' ''') mock_resource_remove = self.call(group.getchildren()[1:]) self.assertEqual( mock_resource_remove.mock_calls, [ mock.call('ip'), mock.call('booth'), ] ) class CreateInClusterTest(TestCase): def test_remove_ip_when_booth_resource_add_failed(self): mock_resource_create = mock.Mock(side_effect=[None, SystemExit(1)]) mock_resource_remove = mock.Mock() mock_create_id = mock.Mock(side_effect=["ip_id","booth_id","group_id"]) ip = "1.2.3.4" booth_config_file_path = rc("/path/to/booth.conf") booth_resource.get_creator(mock_resource_create, mock_resource_remove)( ip, booth_config_file_path, mock_create_id ) self.assertEqual(mock_resource_create.mock_calls, [ mock.call( clone_opts=[], group=u'group_id', meta_values=[], op_values=[], ra_id=u'ip_id', ra_type=u'ocf:heartbeat:IPaddr2', ra_values=[u'ip=1.2.3.4'], ), mock.call( clone_opts=[], group='group_id', meta_values=[], op_values=[], ra_id='booth_id', ra_type='ocf:pacemaker:booth-site', ra_values=['config=/path/to/booth.conf'], ) ]) mock_resource_remove.assert_called_once_with("ip_id") class FindBindedIpTest(TestCase): def fixture_resource_section(self, ip_element_list): resources_section = etree.fromstring('') group = etree.SubElement(resources_section, "group") group.append(fixture_booth_element("booth1", "/PATH/TO/CONF")) for ip_element in ip_element_list: group.append(ip_element) return resources_section def test_returns_None_when_no_ip(self): self.assertEqual( [], booth_resource.find_bound_ip( self.fixture_resource_section([]), "/PATH/TO/CONF", ) ) def test_returns_ip_when_correctly_found(self): self.assertEqual( ["192.168.122.31"], booth_resource.find_bound_ip( self.fixture_resource_section([ fixture_ip_element("ip1", "192.168.122.31"), ]), "/PATH/TO/CONF", ) ) def test_returns_None_when_more_ip(self): self.assertEqual( ["192.168.122.31", "192.168.122.32"], booth_resource.find_bound_ip( self.fixture_resource_section([ fixture_ip_element("ip1", "192.168.122.31"), fixture_ip_element("ip2", "192.168.122.32"), ]), "/PATH/TO/CONF", ) ) pcs-0.9.155/pcs/lib/booth/test/test_status.py000066400000000000000000000105351301012375000210350ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase try: # python 2 #pylint: disable=unused-import from urlparse import parse_qs as url_decode except ImportError: # python 3 from urllib.parse import parse_qs as url_decode from pcs.test.tools.pcs_unittest import mock from pcs.test.tools.assertions import assert_raise_library_error from pcs import settings from pcs.common import report_codes from pcs.lib.errors import ReportItemSeverity as Severities from pcs.lib.external import CommandRunner import pcs.lib.booth.status as lib class GetDaemonStatusTest(TestCase): def setUp(self): self.mock_run = mock.MagicMock(spec_set=CommandRunner) def test_no_name(self): self.mock_run.run.return_value = ("output", "", 0) self.assertEqual("output", lib.get_daemon_status(self.mock_run)) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "status"] ) def test_with_name(self): self.mock_run.run.return_value = ("output", "", 0) self.assertEqual("output", lib.get_daemon_status(self.mock_run, "name")) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "status", "-c", "name"] ) def test_daemon_not_running(self): self.mock_run.run.return_value = ("", "error", 7) self.assertEqual("", lib.get_daemon_status(self.mock_run)) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "status"] ) def test_failure(self): self.mock_run.run.return_value = ("out", "error", 1) assert_raise_library_error( lambda: lib.get_daemon_status(self.mock_run), ( Severities.ERROR, report_codes.BOOTH_DAEMON_STATUS_ERROR, {"reason": "error\nout"} ) ) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "status"] ) class GetTicketsStatusTest(TestCase): def setUp(self): self.mock_run = mock.MagicMock(spec_set=CommandRunner) def test_no_name(self): self.mock_run.run.return_value = ("output", "", 0) self.assertEqual("output", lib.get_tickets_status(self.mock_run)) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "list"] ) def test_with_name(self): self.mock_run.run.return_value = ("output", "", 0) self.assertEqual( "output", lib.get_tickets_status(self.mock_run, "name") ) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "list", "-c", "name"] ) def test_failure(self): self.mock_run.run.return_value = ("out", "error", 1) assert_raise_library_error( lambda: lib.get_tickets_status(self.mock_run), ( Severities.ERROR, report_codes.BOOTH_TICKET_STATUS_ERROR, { "reason": "error\nout" } ) ) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "list"] ) class GetPeersStatusTest(TestCase): def setUp(self): self.mock_run = mock.MagicMock(spec_set=CommandRunner) def test_no_name(self): self.mock_run.run.return_value = ("output", "", 0) self.assertEqual("output", lib.get_peers_status(self.mock_run)) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "peers"] ) def test_with_name(self): self.mock_run.run.return_value = ("output", "", 0) self.assertEqual("output", lib.get_peers_status(self.mock_run, "name")) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "peers", "-c", "name"] ) def test_failure(self): self.mock_run.run.return_value = ("out", "error", 1) assert_raise_library_error( lambda: lib.get_peers_status(self.mock_run), ( Severities.ERROR, report_codes.BOOTH_PEERS_STATUS_ERROR, { "reason": "error\nout" } ) ) self.mock_run.run.assert_called_once_with( [settings.booth_binary, "peers"] ) pcs-0.9.155/pcs/lib/booth/test/test_sync.py000066400000000000000000001222351301012375000204670ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase import json import base64 try: # python 2 from urlparse import parse_qs as url_decode except ImportError: # python 3 from urllib.parse import parse_qs as url_decode from pcs.test.tools.pcs_unittest import mock from pcs.test.tools.assertions import ( assert_report_item_list_equal, assert_raise_library_error, ) from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.common import report_codes from pcs.lib.node import NodeAddresses, NodeAddressesList from pcs.lib.errors import LibraryError, ReportItemSeverity as Severities from pcs.lib.external import NodeCommunicator, NodeConnectionException import pcs.lib.booth.sync as lib def to_b64(string): return base64.b64encode(string.encode("utf-8")).decode("utf-8") class SetConfigOnNodeTest(TestCase): def setUp(self): self.mock_com = mock.MagicMock(spec_set=NodeCommunicator) self.mock_rep = MockLibraryReportProcessor() self.node = NodeAddresses("node") def test_with_authfile(self): lib._set_config_on_node( self.mock_com, self.mock_rep, self.node, "cfg_name", "cfg", authfile="/abs/path/my-key.key", authfile_data="test key".encode("utf-8") ) self.assertEqual(1, self.mock_com.call_node.call_count) self.assertEqual(self.node, self.mock_com.call_node.call_args[0][0]) self.assertEqual( "remote/booth_set_config", self.mock_com.call_node.call_args[0][1] ) data = url_decode(self.mock_com.call_node.call_args[0][2]) self.assertTrue("data_json" in data) self.assertEqual( { "config": { "name": "cfg_name.conf", "data": "cfg" }, "authfile": { "name": "my-key.key", "data": to_b64("test key") } }, json.loads(data["data_json"][0]) ) assert_report_item_list_equal( self.mock_rep.report_item_list, [( Severities.INFO, report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE, { "node": self.node.label, "name_list": ["cfg_name"] } )] ) def _assert(self): self.assertEqual(1, self.mock_com.call_node.call_count) self.assertEqual(self.node, self.mock_com.call_node.call_args[0][0]) self.assertEqual( "remote/booth_set_config", self.mock_com.call_node.call_args[0][1] ) data = url_decode(self.mock_com.call_node.call_args[0][2]) self.assertTrue("data_json" in data) self.assertEqual( { "config": { "name": "cfg_name.conf", "data": "cfg" } }, json.loads(data["data_json"][0]) ) assert_report_item_list_equal( self.mock_rep.report_item_list, [( Severities.INFO, report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE, { "node": self.node.label, "name_list": ["cfg_name"] } )] ) def test_authfile_data_None(self): lib._set_config_on_node( self.mock_com, self.mock_rep, self.node, "cfg_name", "cfg", authfile="key.key" ) self._assert() def test_authfile_only_data(self): lib._set_config_on_node( self.mock_com, self.mock_rep, self.node, "cfg_name", "cfg", authfile_data="key".encode("utf-8") ) self._assert() def test_without_authfile(self): lib._set_config_on_node( self.mock_com, self.mock_rep, self.node, "cfg_name", "cfg" ) self._assert() @mock.patch("pcs.lib.booth.sync.parallel_nodes_communication_helper") class SyncConfigInCluster(TestCase): def setUp(self): self.mock_communicator = mock.MagicMock(spec_set=NodeCommunicator) self.mock_reporter = MockLibraryReportProcessor() self.node_list = NodeAddressesList( [NodeAddresses("node" + str(i) for i in range(5))] ) def test_without_authfile(self, mock_parallel): lib.send_config_to_all_nodes( self.mock_communicator, self.mock_reporter, self.node_list, "cfg_name", "config data" ) mock_parallel.assert_called_once_with( lib._set_config_on_node, [ ( [ self.mock_communicator, self.mock_reporter, node, "cfg_name", "config data", None, None ], {} ) for node in self.node_list ], self.mock_reporter, False ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [( Severities.INFO, report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED, {} )] ) def test_skip_offline(self, mock_parallel): lib.send_config_to_all_nodes( self.mock_communicator, self.mock_reporter, self.node_list, "cfg_name", "config data", skip_offline=True ) mock_parallel.assert_called_once_with( lib._set_config_on_node, [ ( [ self.mock_communicator, self.mock_reporter, node, "cfg_name", "config data", None, None ], {} ) for node in self.node_list ], self.mock_reporter, True ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [( Severities.INFO, report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED, {} )] ) def test_with_authfile(self, mock_parallel): lib.send_config_to_all_nodes( self.mock_communicator, self.mock_reporter, self.node_list, "cfg_name", "config data", authfile="/my/auth/file.key", authfile_data="authfile data".encode("utf-8") ) mock_parallel.assert_called_once_with( lib._set_config_on_node, [ ( [ self.mock_communicator, self.mock_reporter, node, "cfg_name", "config data", "/my/auth/file.key", "authfile data".encode("utf-8") ], {} ) for node in self.node_list ], self.mock_reporter, False ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [( Severities.INFO, report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED, {} )] ) @mock.patch("pcs.lib.booth.config_structure.get_authfile") @mock.patch("pcs.lib.booth.config_parser.parse") @mock.patch("pcs.lib.booth.config_files.read_configs") @mock.patch("pcs.lib.booth.config_files.read_authfile") class SendAllConfigToNodeTest(TestCase): def setUp(self): self.mock_communicator = mock.MagicMock(spec_set=NodeCommunicator) self.mock_reporter = MockLibraryReportProcessor() self.node = NodeAddresses("node") @staticmethod def mock_parse_fn(config_content): if config_content not in ["config1", "config2"]: raise AssertionError( "unexpected input {0}".format(config_content) ) return config_content @staticmethod def mock_authfile_fn(parsed_config): _data = { "config1": "/path/to/file1.key", "config2": "/path/to/file2.key" } if parsed_config not in _data: raise AssertionError( "unexpected input {0}".format(parsed_config) ) return _data[parsed_config] @staticmethod def mock_read_authfile_fn(_, authfile_path): _data = { "/path/to/file1.key": "some key".encode("utf-8"), "/path/to/file2.key": "another key".encode("utf-8"), } if authfile_path not in _data: raise AssertionError( "unexpected input {0}".format(authfile_path) ) return _data[authfile_path] def test_success( self, mock_read_authfile, mock_read_configs, mock_parse, mock_authfile ): mock_parse.side_effect = self.mock_parse_fn mock_authfile.side_effect = self.mock_authfile_fn mock_read_authfile.side_effect = self.mock_read_authfile_fn mock_read_configs.return_value = { "name1.conf": "config1", "name2.conf": "config2" } self.mock_communicator.call_node.return_value = """ { "existing": [], "failed": {}, "saved": ["name1.conf", "file1.key", "name2.conf", "file2.key"] } """ lib.send_all_config_to_node( self.mock_communicator, self.mock_reporter, self.node ) self.assertEqual(2, mock_parse.call_count) mock_parse.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_authfile.call_count) mock_authfile.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_read_authfile.call_count) mock_read_authfile.assert_has_calls([ mock.call(self.mock_reporter, "/path/to/file1.key"), mock.call(self.mock_reporter, "/path/to/file2.key") ]) mock_read_configs.assert_called_once_with(self.mock_reporter, False) self.assertEqual(1, self.mock_communicator.call_node.call_count) self.assertEqual( self.node, self.mock_communicator.call_node.call_args[0][0] ) self.assertEqual( "remote/booth_save_files", self.mock_communicator.call_node.call_args[0][1] ) data = url_decode(self.mock_communicator.call_node.call_args[0][2]) self.assertFalse("rewrite_existing" in data) self.assertTrue("data_json" in data) self.assertEqual( [ { "name": "name1.conf", "data": "config1", "is_authfile": False }, { "name": "file1.key", "data": to_b64("some key"), "is_authfile": True }, { "name": "name2.conf", "data": "config2", "is_authfile": False }, { "name": "file2.key", "data": to_b64("another key"), "is_authfile": True } ], json.loads(data["data_json"][0]) ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [ ( Severities.INFO, report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED, {} ), ( Severities.INFO, report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE, { "node": self.node.label, "name_list": [ "name1.conf", "file1.key", "name2.conf", "file2.key" ] } ) ] ) def test_do_not_rewrite_existing( self, mock_read_authfile, mock_read_configs, mock_parse, mock_authfile ): mock_parse.side_effect = self.mock_parse_fn mock_authfile.side_effect = self.mock_authfile_fn mock_read_authfile.side_effect = self.mock_read_authfile_fn mock_read_configs.return_value = { "name1.conf": "config1", "name2.conf": "config2" } self.mock_communicator.call_node.return_value = """ { "existing": ["name1.conf", "file1.key"], "failed": {}, "saved": ["name2.conf", "file2.key"] } """ assert_raise_library_error( lambda: lib.send_all_config_to_node( self.mock_communicator, self.mock_reporter, self.node ), ( Severities.ERROR, report_codes.FILE_ALREADY_EXISTS, { "file_role": None, "file_path": "name1.conf", "node": self.node.label }, report_codes.FORCE_FILE_OVERWRITE ), ( Severities.ERROR, report_codes.FILE_ALREADY_EXISTS, { "file_role": None, "file_path": "file1.key", "node": self.node.label }, report_codes.FORCE_FILE_OVERWRITE ) ) self.assertEqual(2, mock_parse.call_count) mock_parse.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_authfile.call_count) mock_authfile.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_read_authfile.call_count) mock_read_authfile.assert_has_calls([ mock.call(self.mock_reporter, "/path/to/file1.key"), mock.call(self.mock_reporter, "/path/to/file2.key") ]) mock_read_configs.assert_called_once_with(self.mock_reporter, False) self.assertEqual(1, self.mock_communicator.call_node.call_count) self.assertEqual( self.node, self.mock_communicator.call_node.call_args[0][0] ) self.assertEqual( "remote/booth_save_files", self.mock_communicator.call_node.call_args[0][1] ) data = url_decode(self.mock_communicator.call_node.call_args[0][2]) self.assertFalse("rewrite_existing" in data) self.assertTrue("data_json" in data) self.assertEqual( [ { "name": "name1.conf", "data": "config1", "is_authfile": False }, { "name": "file1.key", "data": to_b64("some key"), "is_authfile": True }, { "name": "name2.conf", "data": "config2", "is_authfile": False }, { "name": "file2.key", "data": to_b64("another key"), "is_authfile": True } ], json.loads(data["data_json"][0]) ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [ ( Severities.INFO, report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED, {} ), ( Severities.ERROR, report_codes.FILE_ALREADY_EXISTS, { "file_role": None, "file_path": "name1.conf", "node": self.node.label }, report_codes.FORCE_FILE_OVERWRITE ), ( Severities.ERROR, report_codes.FILE_ALREADY_EXISTS, { "file_role": None, "file_path": "file1.key", "node": self.node.label }, report_codes.FORCE_FILE_OVERWRITE ) ] ) def test_rewrite_existing( self, mock_read_authfile, mock_read_configs, mock_parse, mock_authfile ): mock_parse.side_effect = self.mock_parse_fn mock_authfile.side_effect = self.mock_authfile_fn mock_read_authfile.side_effect = self.mock_read_authfile_fn mock_read_configs.return_value = { "name1.conf": "config1", "name2.conf": "config2" } self.mock_communicator.call_node.return_value = """ { "existing": ["name1.conf", "file1.key"], "failed": {}, "saved": ["name2.conf", "file2.key"] } """ lib.send_all_config_to_node( self.mock_communicator, self.mock_reporter, self.node, rewrite_existing=True ) mock_read_configs.assert_called_once_with(self.mock_reporter, False) self.assertEqual(2, mock_parse.call_count) mock_parse.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_authfile.call_count) mock_authfile.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_read_authfile.call_count) mock_read_authfile.assert_has_calls([ mock.call(self.mock_reporter, "/path/to/file1.key"), mock.call(self.mock_reporter, "/path/to/file2.key") ]) self.assertEqual(1, self.mock_communicator.call_node.call_count) self.assertEqual( self.node, self.mock_communicator.call_node.call_args[0][0] ) self.assertEqual( "remote/booth_save_files", self.mock_communicator.call_node.call_args[0][1] ) data = url_decode(self.mock_communicator.call_node.call_args[0][2]) self.assertTrue("rewrite_existing" in data) self.assertTrue("data_json" in data) self.assertEqual( [ { "name": "name1.conf", "data": "config1", "is_authfile": False }, { "name": "file1.key", "data": to_b64("some key"), "is_authfile": True }, { "name": "name2.conf", "data": "config2", "is_authfile": False }, { "name": "file2.key", "data": to_b64("another key"), "is_authfile": True } ], json.loads(data["data_json"][0]) ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [ ( Severities.INFO, report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED, {} ), ( Severities.WARNING, report_codes.FILE_ALREADY_EXISTS, { "file_role": None, "file_path": "name1.conf", "node": self.node.label } ), ( Severities.WARNING, report_codes.FILE_ALREADY_EXISTS, { "file_role": None, "file_path": "file1.key", "node": self.node.label } ), ( Severities.INFO, report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE, { "node": self.node.label, "name_list": ["name2.conf", "file2.key"] } ) ] ) def test_write_failure( self, mock_read_authfile, mock_read_configs, mock_parse, mock_authfile ): mock_parse.side_effect = self.mock_parse_fn mock_authfile.side_effect = self.mock_authfile_fn mock_read_authfile.side_effect = self.mock_read_authfile_fn mock_read_configs.return_value = { "name1.conf": "config1", "name2.conf": "config2" } self.mock_communicator.call_node.return_value = """ { "existing": [], "failed": { "name1.conf": "Error message", "file1.key": "Another error message" }, "saved": ["name2.conf", "file2.key"] } """ assert_raise_library_error( lambda: lib.send_all_config_to_node( self.mock_communicator, self.mock_reporter, self.node ), ( Severities.ERROR, report_codes.BOOTH_CONFIG_DISTRIBUTION_NODE_ERROR, { "node": self.node.label, "name": "name1.conf", "reason": "Error message" } ), ( Severities.ERROR, report_codes.BOOTH_CONFIG_DISTRIBUTION_NODE_ERROR, { "node": self.node.label, "name": "file1.key", "reason": "Another error message" } ) ) self.assertEqual(2, mock_parse.call_count) mock_parse.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_authfile.call_count) mock_authfile.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_read_authfile.call_count) mock_read_authfile.assert_has_calls([ mock.call(self.mock_reporter, "/path/to/file1.key"), mock.call(self.mock_reporter, "/path/to/file2.key") ]) mock_read_configs.assert_called_once_with(self.mock_reporter, False) self.assertEqual(1, self.mock_communicator.call_node.call_count) self.assertEqual( self.node, self.mock_communicator.call_node.call_args[0][0] ) self.assertEqual( "remote/booth_save_files", self.mock_communicator.call_node.call_args[0][1] ) data = url_decode(self.mock_communicator.call_node.call_args[0][2]) self.assertFalse("rewrite_existing" in data) self.assertTrue("data_json" in data) self.assertEqual( [ { "name": "name1.conf", "data": "config1", "is_authfile": False }, { "name": "file1.key", "data": to_b64("some key"), "is_authfile": True }, { "name": "name2.conf", "data": "config2", "is_authfile": False }, { "name": "file2.key", "data": to_b64("another key"), "is_authfile": True } ], json.loads(data["data_json"][0]) ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [ ( Severities.INFO, report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED, {} ), ( Severities.ERROR, report_codes.BOOTH_CONFIG_DISTRIBUTION_NODE_ERROR, { "node": self.node.label, "name": "name1.conf", "reason": "Error message" } ), ( Severities.ERROR, report_codes.BOOTH_CONFIG_DISTRIBUTION_NODE_ERROR, { "node": self.node.label, "name": "file1.key", "reason": "Another error message" } ) ] ) def test_communication_failure( self, mock_read_authfile, mock_read_configs, mock_parse, mock_authfile ): mock_parse.side_effect = self.mock_parse_fn mock_authfile.side_effect = self.mock_authfile_fn mock_read_authfile.side_effect = self.mock_read_authfile_fn mock_read_configs.return_value = { "name1.conf": "config1", "name2.conf": "config2" } self.mock_communicator.call_node.side_effect = NodeConnectionException( self.node.label, "command", "reason" ) assert_raise_library_error( lambda: lib.send_all_config_to_node( self.mock_communicator, self.mock_reporter, self.node ), ( Severities.ERROR, report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT, { "node": self.node.label, "command": "command", "reason": "reason" } ) ) self.assertEqual(2, mock_parse.call_count) mock_parse.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_authfile.call_count) mock_authfile.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_read_authfile.call_count) mock_read_authfile.assert_has_calls([ mock.call(self.mock_reporter, "/path/to/file1.key"), mock.call(self.mock_reporter, "/path/to/file2.key") ]) mock_read_configs.assert_called_once_with(self.mock_reporter, False) self.assertEqual(1, self.mock_communicator.call_node.call_count) self.assertEqual( self.node, self.mock_communicator.call_node.call_args[0][0] ) self.assertEqual( "remote/booth_save_files", self.mock_communicator.call_node.call_args[0][1] ) data = url_decode(self.mock_communicator.call_node.call_args[0][2]) self.assertFalse("rewrite_existing" in data) self.assertTrue("data_json" in data) self.assertEqual( [ { "name": "name1.conf", "data": "config1", "is_authfile": False }, { "name": "file1.key", "data": to_b64("some key"), "is_authfile": True }, { "name": "name2.conf", "data": "config2", "is_authfile": False }, { "name": "file2.key", "data": to_b64("another key"), "is_authfile": True } ], json.loads(data["data_json"][0]) ) def test_wrong_response_format( self, mock_read_authfile, mock_read_configs, mock_parse, mock_authfile ): mock_parse.side_effect = self.mock_parse_fn mock_authfile.side_effect = self.mock_authfile_fn mock_read_authfile.side_effect = self.mock_read_authfile_fn mock_read_configs.return_value = { "name1.conf": "config1", "name2.conf": "config2" } self.mock_communicator.call_node.return_value = """ { "existing_files": [], "failed": { "name1.conf": "Error message", "file1.key": "Another error message" }, "saved": ["name2.conf", "file2.key"] } """ assert_raise_library_error( lambda: lib.send_all_config_to_node( self.mock_communicator, self.mock_reporter, self.node ), ( Severities.ERROR, report_codes.INVALID_RESPONSE_FORMAT, {"node": self.node.label} ) ) self.assertEqual(2, mock_parse.call_count) mock_parse.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_authfile.call_count) mock_authfile.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_read_authfile.call_count) mock_read_authfile.assert_has_calls([ mock.call(self.mock_reporter, "/path/to/file1.key"), mock.call(self.mock_reporter, "/path/to/file2.key") ]) mock_read_configs.assert_called_once_with(self.mock_reporter, False) self.assertEqual(1, self.mock_communicator.call_node.call_count) self.assertEqual( self.node, self.mock_communicator.call_node.call_args[0][0] ) self.assertEqual( "remote/booth_save_files", self.mock_communicator.call_node.call_args[0][1] ) data = url_decode(self.mock_communicator.call_node.call_args[0][2]) self.assertFalse("rewrite_existing" in data) self.assertTrue("data_json" in data) self.assertEqual( [ { "name": "name1.conf", "data": "config1", "is_authfile": False }, { "name": "file1.key", "data": to_b64("some key"), "is_authfile": True }, { "name": "name2.conf", "data": "config2", "is_authfile": False }, { "name": "file2.key", "data": to_b64("another key"), "is_authfile": True } ], json.loads(data["data_json"][0]) ) def test_response_not_json( self, mock_read_authfile, mock_read_configs, mock_parse, mock_authfile ): mock_parse.side_effect = self.mock_parse_fn mock_authfile.side_effect = self.mock_authfile_fn mock_read_authfile.side_effect = self.mock_read_authfile_fn mock_read_configs.return_value = { "name1.conf": "config1", "name2.conf": "config2" } self.mock_communicator.call_node.return_value = "not json" assert_raise_library_error( lambda: lib.send_all_config_to_node( self.mock_communicator, self.mock_reporter, self.node ), ( Severities.ERROR, report_codes.INVALID_RESPONSE_FORMAT, {"node": self.node.label} ) ) self.assertEqual(2, mock_parse.call_count) mock_parse.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_authfile.call_count) mock_authfile.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_read_authfile.call_count) mock_read_authfile.assert_has_calls([ mock.call(self.mock_reporter, "/path/to/file1.key"), mock.call(self.mock_reporter, "/path/to/file2.key") ]) mock_read_configs.assert_called_once_with(self.mock_reporter, False) self.assertEqual(1, self.mock_communicator.call_node.call_count) self.assertEqual( self.node, self.mock_communicator.call_node.call_args[0][0] ) self.assertEqual( "remote/booth_save_files", self.mock_communicator.call_node.call_args[0][1] ) data = url_decode(self.mock_communicator.call_node.call_args[0][2]) self.assertFalse("rewrite_existing" in data) self.assertTrue("data_json" in data) self.assertEqual( [ { "name": "name1.conf", "data": "config1", "is_authfile": False }, { "name": "file1.key", "data": to_b64("some key"), "is_authfile": True }, { "name": "name2.conf", "data": "config2", "is_authfile": False }, { "name": "file2.key", "data": to_b64("another key"), "is_authfile": True } ], json.loads(data["data_json"][0]) ) def test_configs_without_authfiles( self, mock_read_authfile, mock_read_configs, mock_parse, mock_authfile ): def mock_authfile_fn(parsed_config): if parsed_config == "config1": return None elif parsed_config == "config2": return "/path/to/file2.key" else: raise AssertionError( "unexpected input: {0}".format(parsed_config) ) mock_parse.side_effect = self.mock_parse_fn mock_authfile.side_effect = mock_authfile_fn mock_read_authfile.return_value = "another key".encode("utf-8") mock_read_configs.return_value = { "name1.conf": "config1", "name2.conf": "config2" } self.mock_communicator.call_node.return_value = """ { "existing": [], "failed": {}, "saved": ["name1.conf", "name2.conf", "file2.key"] } """ lib.send_all_config_to_node( self.mock_communicator, self.mock_reporter, self.node ) self.assertEqual(2, mock_parse.call_count) mock_parse.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) self.assertEqual(2, mock_authfile.call_count) mock_authfile.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) mock_read_authfile.assert_called_once_with( self.mock_reporter, "/path/to/file2.key" ) mock_read_configs.assert_called_once_with(self.mock_reporter, False) self.assertEqual(1, self.mock_communicator.call_node.call_count) self.assertEqual( self.node, self.mock_communicator.call_node.call_args[0][0] ) self.assertEqual( "remote/booth_save_files", self.mock_communicator.call_node.call_args[0][1] ) data = url_decode(self.mock_communicator.call_node.call_args[0][2]) self.assertFalse("rewrite_existing" in data) self.assertTrue("data_json" in data) self.assertEqual( [ { "name": "name1.conf", "data": "config1", "is_authfile": False }, { "name": "name2.conf", "data": "config2", "is_authfile": False }, { "name": "file2.key", "data": to_b64("another key"), "is_authfile": True } ], json.loads(data["data_json"][0]) ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [ ( Severities.INFO, report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED, {} ), ( Severities.INFO, report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE, { "node": self.node.label, "name_list": ["name1.conf", "name2.conf", "file2.key"] } ) ] ) def test_unable_to_parse_config( self, mock_read_authfile, mock_read_configs, mock_parse, mock_authfile ): def mock_parse_fn(config_data): if config_data == "config1": raise LibraryError() elif config_data == "config2": return "config2" else: raise AssertionError( "unexpected input: {0}".format(config_data) ) mock_parse.side_effect = mock_parse_fn mock_authfile.return_value = "/path/to/file2.key" mock_read_authfile.return_value = "another key".encode("utf-8") mock_read_configs.return_value = { "name1.conf": "config1", "name2.conf": "config2" } self.mock_communicator.call_node.return_value = """ { "existing": [], "failed": {}, "saved": ["name2.conf", "file2.key"] } """ lib.send_all_config_to_node( self.mock_communicator, self.mock_reporter, self.node ) self.assertEqual(2, mock_parse.call_count) mock_parse.assert_has_calls([ mock.call("config1"), mock.call("config2") ]) mock_authfile.assert_called_once_with("config2") mock_read_authfile.assert_called_once_with( self.mock_reporter, "/path/to/file2.key" ) mock_read_configs.assert_called_once_with(self.mock_reporter, False) self.assertEqual(1, self.mock_communicator.call_node.call_count) self.assertEqual( self.node, self.mock_communicator.call_node.call_args[0][0] ) self.assertEqual( "remote/booth_save_files", self.mock_communicator.call_node.call_args[0][1] ) data = url_decode(self.mock_communicator.call_node.call_args[0][2]) self.assertFalse("rewrite_existing" in data) self.assertTrue("data_json" in data) self.assertEqual( [ { "name": "name2.conf", "data": "config2", "is_authfile": False }, { "name": "file2.key", "data": to_b64("another key"), "is_authfile": True } ], json.loads(data["data_json"][0]) ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [ ( Severities.INFO, report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED, {} ), ( Severities.WARNING, report_codes.BOOTH_SKIPPING_CONFIG, { "config_file": "name1.conf" } ), ( Severities.INFO, report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE, { "node": self.node.label, "name_list": ["name2.conf", "file2.key"] } ) ] ) class PullConfigFromNodeTest(TestCase): def setUp(self): self.mock_communicator = mock.MagicMock(spec_set=NodeCommunicator) self.node = NodeAddresses("node") def test_success(self): self.mock_communicator.call_node.return_value = "{}" self.assertEqual( {}, lib.pull_config_from_node( self.mock_communicator, self.node, "booth" ) ) self.mock_communicator.call_node.assert_called_once_with( self.node, "remote/booth_get_config", "name=booth" ) def test_not_json(self): self.mock_communicator.call_node.return_value = "not json" assert_raise_library_error( lambda: lib.pull_config_from_node( self.mock_communicator, self.node, "booth" ), ( Severities.ERROR, report_codes.INVALID_RESPONSE_FORMAT, {"node": self.node.label} ) ) def test_communication_failure(self): self.mock_communicator.call_node.side_effect = NodeConnectionException( self.node.label, "command", "reason" ) assert_raise_library_error( lambda: lib.pull_config_from_node( self.mock_communicator, self.node, "booth" ), ( Severities.ERROR, report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT, { "node": self.node.label, "command": "command", "reason": "reason" } ) ) pcs-0.9.155/pcs/lib/cib/000077500000000000000000000000001301012375000145405ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/cib/__init__.py000066400000000000000000000000001301012375000166370ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/cib/acl.py000066400000000000000000000312571301012375000156610ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from lxml import etree from pcs.lib import reports from pcs.lib.errors import LibraryError from pcs.lib.cib.tools import ( etree_element_attibutes_to_dict, check_new_id_applicable, does_id_exist, find_unique_id, get_acls, ) class AclError(Exception): pass class AclRoleNotFound(AclError): # pylint: disable=super-init-not-called def __init__(self, role_id): self.role_id = role_id class AclTargetNotFound(AclError): # pylint: disable=super-init-not-called def __init__(self, target_id): self.target_id = target_id class AclGroupNotFound(AclError): # pylint: disable=super-init-not-called def __init__(self, group_id): self.group_id = group_id def validate_permissions(tree, permission_info_list): """ Validate given permission list. Raise LibraryError if any of permission is not valid. tree -- cib tree permission_info_list -- list of tuples like this: ("read|write|deny", "xpath|id", ) """ report_items = [] allowed_permissions = ["read", "write", "deny"] allowed_scopes = ["xpath", "id"] for permission, scope_type, scope in permission_info_list: if not permission in allowed_permissions: report_items.append(reports.invalid_option_value( "permission", permission, allowed_permissions )) if not scope_type in allowed_scopes: report_items.append(reports.invalid_option_value( "scope type", scope_type, allowed_scopes )) if scope_type == 'id' and not does_id_exist(tree, scope): report_items.append(reports.id_not_found(scope, "id")) if report_items: raise LibraryError(*report_items) def find_role(tree, role_id): """ Returns acl_role element with specified role_id in given tree. Raise AclRoleNotFound if role doesn't exist. tree -- etree node role_id -- id of role """ role = tree.find('.//acl_role[@id="{0}"]'.format(role_id)) if role is not None: return role raise AclRoleNotFound(role_id) def _find_permission(tree, permission_id): """ Returns acl_permission element with specified id. Raises LibraryError if that permission doesn't exist. tree -- etree node permisson_id -- id of permision element """ permission = tree.find(".//acl_permission[@id='{0}']".format(permission_id)) if permission is not None: return permission raise LibraryError(reports.id_not_found(permission_id, "permission")) def create_role(tree, role_id, description=None): """ Create new role element and add it to cib. Returns newly created role element. role_id id of desired role description role description """ check_new_id_applicable(tree, "ACL role", role_id) role = etree.SubElement(get_acls(tree), "acl_role", id=role_id) if description: role.set("description", description) return role def remove_role(tree, role_id, autodelete_users_groups=False): """ Remove role with specified id from CIB and all references to it. tree -- etree node role_id -- id of role to be removed autodelete_users_group -- if True remove targets with no role after removing """ acl_role = find_role(tree, role_id) acl_role.getparent().remove(acl_role) for role_el in tree.findall(".//role[@id='{0}']".format(role_id)): role_parent = role_el.getparent() role_parent.remove(role_el) if autodelete_users_groups and role_parent.find(".//role") is None: role_parent.getparent().remove(role_parent) def assign_role(target_el, role_el): """ Assign role element to specified target/group element. Raise LibraryError if role is already assigned to target/group. target_el -- etree element of target/group to which role should be assign role_el -- etree element of role """ assigned_role = target_el.find( "./role[@id='{0}']".format(role_el.get("id")) ) if assigned_role is not None: raise LibraryError(reports.acl_role_is_already_assigned_to_target( role_el.get("id"), target_el.get("id") )) etree.SubElement(target_el, "role", {"id": role_el.get("id")}) def unassign_role(target_el, role_id, autodelete_target=False): """ Unassign role with role_id from specified target/user target_el. Raise LibraryError if role is not assigned to target/group. target_el -- etree element of target/group from which role should be unassign role_id -- id of role autodelete_target -- if True remove target_el if there is no role assigned """ assigned_role = target_el.find("./role[@id='{0}']".format(role_id)) if assigned_role is None: raise LibraryError(reports.acl_role_is_not_assigned_to_target( role_id, target_el.get("id") )) target_el.remove(assigned_role) if autodelete_target and target_el.find("./role") is None: target_el.getparent().remove(target_el) def find_target(tree, target_id): """ Return acl_target etree element with specified id. Raise AclTargetNotFound if target with specified id doesn't exist. tree -- etree node target_id -- if of target to find """ role = get_acls(tree).find('./acl_target[@id="{0}"]'.format(target_id)) if role is None: raise AclTargetNotFound(target_id) return role def find_group(tree, group_id): """ Returns acl_group etree element with specified id. Raise AclGroupNotFound if group with group_id doesn't exist. tree -- etree node group_id -- id of group to find """ role = get_acls(tree).find('./acl_group[@id="{0}"]'.format(group_id)) if role is None: raise AclGroupNotFound(group_id) return role def provide_role(tree, role_id): """ Returns role with id role_id. If doesn't exist, it will be created. role_id id of desired role """ try: return find_role(tree, role_id) except AclRoleNotFound: return create_role(tree, role_id) def create_target(tree, target_id): """ Creates new acl_target element with id target_id. Raises LibraryError if target with wpecified id aleready exists. tree -- etree node target_id -- id of new target """ acl_el = get_acls(tree) # id of element acl_target is not type ID in CIB ACL schema so we don't need # to check if it is unique ID in whole CIB if acl_el.find("./acl_target[@id='{0}']".format(target_id)) is not None: raise LibraryError(reports.acl_target_already_exists(target_id)) return etree.SubElement(get_acls(tree), "acl_target", id=target_id) def create_group(tree, group_id): """ Creates new acl_group element with specified id. Raises LibraryError if tree contains element with id group_id. tree -- etree node group_id -- id of new group """ check_new_id_applicable(tree, "ACL group", group_id) return etree.SubElement(get_acls(tree), "acl_group", id=group_id) def remove_target(tree, target_id): """ Removes acl_target element from tree with specified id. Raises LibraryError if target with id target_id doesn't exist. tree -- etree node target_id -- id of target element to remove """ try: target = find_target(tree, target_id) target.getparent().remove(target) except AclTargetNotFound: raise LibraryError(reports.id_not_found(target_id, "user")) def remove_group(tree, group_id): """ Removes acl_group element from tree with specified id. Raises LibraryError if group with id group_id doesn't exist. tree -- etree node group_id -- id of group element to remove """ try: group = find_group(tree, group_id) group.getparent().remove(group) except AclGroupNotFound: raise LibraryError(reports.id_not_found(group_id, "group")) def add_permissions_to_role(role_el, permission_info_list): """ Add permissions from permission_info_list to role_el. role_el -- acl_role element to which permissions should be added permission_info_list -- list of tuples, each contains (permission, scope_type, scope) """ area_type_attribute_map = { 'xpath': 'xpath', 'id': 'reference', } for permission, scope_type, scope in permission_info_list: perm = etree.SubElement(role_el, "acl_permission") perm.set( "id", find_unique_id( role_el, "{0}-{1}".format(role_el.get("id", "role"), permission) ) ) perm.set("kind", permission) perm.set(area_type_attribute_map[scope_type], scope) def remove_permission(tree, permission_id): """ Remove permission with id permission_id from tree. tree -- etree node permission_id -- id of permission element to be removed """ permission = _find_permission(tree, permission_id) permission.getparent().remove(permission) def get_role_list(tree): """ Returns list of all acl_role elements from tree. Format of items of output list: { "id": , "description": , "permission_list": [, ...] } tree -- etree node """ output_list = [] for role_el in get_acls(tree).findall("./acl_role"): role = etree_element_attibutes_to_dict( role_el, ["id", "description"] ) role["permission_list"] = _get_permission_list(role_el) output_list.append(role) return output_list def _get_permission_list(role_el): """ Return list of all permissions of role element role_el. Format of item of output list (if attribute is misssing in element under its key there is None): { "id": , "description": , "kind": , "xpath": , "reference": , "object-type": <>, "attribute": <>, } role_el -- acl_role etree element of which permissions whould be returned """ output_list = [] for permission in role_el.findall("./acl_permission"): output_list.append(etree_element_attibutes_to_dict( permission, [ "id", "description", "kind", "xpath", "reference", "object-type", "attribute" ] )) return output_list def get_target_list(tree): """ Returns list of acl_target elements in format: { "id": , "role_list": [, ...] } tree -- etree node """ return _get_target_like_list_with_tag(tree, "acl_target") def get_group_list(tree): """ Returns list of acl_group elements in format: { "id": , "role_list": [, ...] } tree -- etree node """ return _get_target_like_list_with_tag(tree, "acl_group") def _get_target_like_list_with_tag(tree, tag): output_list = [] for target_el in get_acls(tree).findall("./{0}".format(tag)): output_list.append({ "id": target_el.get("id"), "role_list": _get_role_list_of_target(target_el), }) return output_list def _get_role_list_of_target(target): """ Returns all roles assigned to target element as list of strings. target -- etree acl_target/acl_group element of which roles should be returned """ return [ role.get("id") for role in target.findall("./role") if role.get("id") ] def remove_permissions_referencing(tree, reference): """ Removes all permission with specified reference. tree -- etree node reference -- reference identifier """ xpath = './/acl_permission[@reference="{0}"]'.format(reference) for permission in tree.findall(xpath): permission.getparent().remove(permission) def dom_remove_permissions_referencing(dom, reference): # TODO: remove once we go fully lxml for permission in dom.getElementsByTagName("acl_permission"): if permission.getAttribute("reference") == reference: permission.parentNode.removeChild(permission) def acl_error_to_report_item(e): if e.__class__ == AclTargetNotFound: return reports.id_not_found(e.target_id, "user") elif e.__class__ == AclGroupNotFound: return reports.id_not_found(e.group_id, "group") elif e.__class__ == AclRoleNotFound: return reports.id_not_found(e.role_id, "role") raise e pcs-0.9.155/pcs/lib/cib/alert.py000066400000000000000000000217661301012375000162350ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from lxml import etree from functools import partial from pcs.common import report_codes from pcs.lib import reports from pcs.lib.errors import LibraryError, ReportItemSeverity as Severities from pcs.lib.cib.nvpair import arrange_first_nvset, get_nvset from pcs.lib.cib.tools import ( check_new_id_applicable, get_sub_element, find_unique_id, get_alerts, validate_id_does_not_exist, ) update_instance_attributes = partial( arrange_first_nvset, "instance_attributes" ) update_meta_attributes = partial(arrange_first_nvset, "meta_attributes") def _update_optional_attribute(element, attribute, value): """ Update optional attribute of element. Remove existing element if value is empty. element -- parent element of specified attribute attribute -- attribute to be updated value -- new value """ if value is None: return if value: element.set(attribute, value) elif attribute in element.attrib: del element.attrib[attribute] def get_alert_by_id(tree, alert_id): """ Returns alert element with specified id. Raises LibraryError if alert with specified id doesn't exist. tree -- cib etree node alert_id -- id of alert """ alert = get_alerts(tree).find("./alert[@id='{0}']".format(alert_id)) if alert is None: raise LibraryError(reports.cib_alert_not_found(alert_id)) return alert def get_recipient_by_id(tree, recipient_id): """ Returns recipient element with value recipient_value which belong to specified alert. Raises LibraryError if recipient doesn't exist. tree -- cib etree node recipient_id -- id of recipient """ recipient = get_alerts(tree).find( "./alert/recipient[@id='{0}']".format(recipient_id) ) if recipient is None: raise LibraryError(reports.id_not_found(recipient_id, "Recipient")) return recipient def ensure_recipient_value_is_unique( reporter, alert, recipient_value, recipient_id="", allow_duplicity=False ): """ Ensures that recipient_value is unique in alert. reporter -- report processor alert -- alert recipient_value -- recipient value recipient_id -- recipient id of to which value belongs to allow_duplicity -- if True only warning will be shown if value already exists """ recipient_list = alert.xpath( "./recipient[@value='{value}' and @id!='{id}']".format( value=recipient_value, id=recipient_id ) ) if recipient_list: reporter.process(reports.cib_alert_recipient_already_exists( alert.get("id", None), recipient_value, Severities.WARNING if allow_duplicity else Severities.ERROR, forceable=( None if allow_duplicity else report_codes.FORCE_ALERT_RECIPIENT_VALUE_NOT_UNIQUE ) )) def create_alert(tree, alert_id, path, description=""): """ Create new alert element. Returns newly created element. Raises LibraryError if element with specified id already exists. tree -- cib etree node alert_id -- id of new alert, it will be generated if it is None path -- path to script description -- description """ if alert_id: check_new_id_applicable(tree, "alert-id", alert_id) else: alert_id = find_unique_id(tree, "alert") alert = etree.SubElement(get_alerts(tree), "alert", id=alert_id, path=path) if description: alert.set("description", description) return alert def update_alert(tree, alert_id, path, description=None): """ Update existing alert. Return updated alert element. Raises LibraryError if alert with specified id doesn't exist. tree -- cib etree node alert_id -- id of alert to be updated path -- new value of path, stay unchanged if None description -- new value of description, stay unchanged if None, remove if empty """ alert = get_alert_by_id(tree, alert_id) if path: alert.set("path", path) _update_optional_attribute(alert, "description", description) return alert def remove_alert(tree, alert_id): """ Remove alert with specified id. Raises LibraryError if alert with specified id doesn't exist. tree -- cib etree node alert_id -- id of alert which should be removed """ alert = get_alert_by_id(tree, alert_id) alert.getparent().remove(alert) def add_recipient( reporter, tree, alert_id, recipient_value, recipient_id=None, description="", allow_same_value=False ): """ Add recipient to alert with specified id. Returns added recipient element. Raises LibraryError if alert with specified recipient_id doesn't exist. Raises LibraryError if recipient already exists. reporter -- report processor tree -- cib etree node alert_id -- id of alert which should be parent of new recipient recipient_value -- value of recipient recipient_id -- id of new recipient, if None it will be generated description -- description of recipient allow_same_value -- if True unique recipient value is not required """ if recipient_id is None: recipient_id = find_unique_id(tree, "{0}-recipient".format(alert_id)) else: validate_id_does_not_exist(tree, recipient_id) alert = get_alert_by_id(tree, alert_id) ensure_recipient_value_is_unique( reporter, alert, recipient_value, allow_duplicity=allow_same_value ) recipient = etree.SubElement( alert, "recipient", id=recipient_id, value=recipient_value ) if description: recipient.set("description", description) return recipient def update_recipient( reporter, tree, recipient_id, recipient_value=None, description=None, allow_same_value=False ): """ Update specified recipient. Returns updated recipient element. Raises LibraryError if recipient doesn't exist. reporter -- report processor tree -- cib etree node recipient_id -- id of recipient to be updated recipient_value -- recipient value, stay unchanged if None description -- description, if empty it will be removed, stay unchanged if None allow_same_value -- if True unique recipient value is not required """ recipient = get_recipient_by_id(tree, recipient_id) if recipient_value is not None: ensure_recipient_value_is_unique( reporter, recipient.getparent(), recipient_value, recipient_id=recipient_id, allow_duplicity=allow_same_value ) recipient.set("value", recipient_value) _update_optional_attribute(recipient, "description", description) return recipient def remove_recipient(tree, recipient_id): """ Remove specified recipient. Raises LibraryError if recipient doesn't exist. tree -- cib etree node recipient_id -- id of recipient to be removed """ recipient = get_recipient_by_id(tree, recipient_id) recipient.getparent().remove(recipient) def get_all_recipients(alert): """ Returns list of all recipient of specified alert. Format: [ { "id": , "value": , "description": , "instance_attributes": , "meta_attributes": } ] alert -- parent element of recipients to return """ recipient_list = [] for recipient in alert.findall("./recipient"): recipient_list.append({ "id": recipient.get("id"), "value": recipient.get("value"), "description": recipient.get("description", ""), "instance_attributes": get_nvset( get_sub_element(recipient, "instance_attributes") ), "meta_attributes": get_nvset( get_sub_element(recipient, "meta_attributes") ) }) return recipient_list def get_all_alerts(tree): """ Returns list of all alerts specified in tree. Format: [ { "id": , "path": , "description": , "instance_attributes": , "meta_attributes": , "recipients_list": } ] tree -- cib etree node """ alert_list = [] for alert in get_alerts(tree).findall("./alert"): alert_list.append({ "id": alert.get("id"), "path": alert.get("path"), "description": alert.get("description", ""), "instance_attributes": get_nvset( get_sub_element(alert, "instance_attributes") ), "meta_attributes": get_nvset( get_sub_element(alert, "meta_attributes") ), "recipient_list": get_all_recipients(alert) }) return alert_list pcs-0.9.155/pcs/lib/cib/constraint/000077500000000000000000000000001301012375000167245ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/cib/constraint/__init__.py000066400000000000000000000000001301012375000210230ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/cib/constraint/colocation.py000066400000000000000000000022751301012375000214360ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from functools import partial from pcs.lib import reports from pcs.lib.cib.constraint import constraint from pcs.lib.cib.tools import check_new_id_applicable from pcs.lib.errors import LibraryError from pcs.lib.pacemaker_values import is_score_value, SCORE_INFINITY TAG_NAME = 'rsc_colocation' DESCRIPTION = "constraint id" SCORE_NAMES = ("score", "score-attribute", "score-attribute-mangle") def prepare_options_with_set(cib, options, resource_set_list): options = constraint.prepare_options( tuple(SCORE_NAMES), options, partial(constraint.create_id, cib, TAG_NAME, resource_set_list), partial(check_new_id_applicable, cib, DESCRIPTION), ) if "score" in options and not is_score_value(options["score"]): raise LibraryError(reports.invalid_score(options["score"])) score_attrs_count = len([ name for name in options.keys() if name in SCORE_NAMES ]) if score_attrs_count > 1: raise LibraryError(reports.multiple_score_options()) if score_attrs_count == 0: options["score"] = SCORE_INFINITY return options pcs-0.9.155/pcs/lib/cib/constraint/constraint.py000066400000000000000000000106471301012375000214720ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from lxml import etree from pcs.common import report_codes from pcs.lib import reports from pcs.lib.cib import resource from pcs.lib.cib.constraint import resource_set from pcs.lib.cib.tools import export_attributes, find_unique_id, find_parent from pcs.lib.errors import LibraryError, ReportItemSeverity def _validate_attrib_names(attrib_names, options): for option_name in options.keys(): if option_name not in attrib_names: raise LibraryError( reports.invalid_option(option_name, attrib_names, None) ) def find_valid_resource_id( report_processor, cib, can_repair_to_clone, in_clone_allowed, id ): resource_element = resource.find_by_id(cib, id) if(resource_element is None): raise LibraryError(reports.resource_does_not_exist(id)) if resource_element.tag in resource.TAGS_CLONE: return resource_element.attrib["id"] clone = find_parent(resource_element, resource.TAGS_CLONE) if clone is None: return resource_element.attrib["id"] if can_repair_to_clone: #this is workaround for web ui, console should not use it, so we do not #warn about it return clone.attrib["id"] if in_clone_allowed: report_processor.process( reports.resource_for_constraint_is_multiinstance( resource_element.attrib["id"], clone.tag, clone.attrib["id"], ReportItemSeverity.WARNING, ) ) return resource_element.attrib["id"] raise LibraryError(reports.resource_for_constraint_is_multiinstance( resource_element.attrib["id"], clone.tag, clone.attrib["id"], ReportItemSeverity.ERROR, #repair to clone is workaround for web ui, so we put only information #about one forceable possibility forceable=report_codes.FORCE_CONSTRAINT_MULTIINSTANCE_RESOURCE )) def prepare_options(attrib_names, options, create_id, validate_id): _validate_attrib_names(attrib_names+("id",), options) options = options.copy() if "id" not in options: options["id"] = create_id() else: validate_id(options["id"]) return options def export_with_set(element): return { "resource_sets": [ resource_set.export(resource_set_item) for resource_set_item in element.findall(".//resource_set") ], "options": export_attributes(element), } def export_plain(element): return {"options": export_attributes(element)} def create_id(cib, type_prefix, resource_set_list): id = "pcs_" +type_prefix +"".join([ "_set_"+"_".join(id_set) for id_set in resource_set.extract_id_set_list(resource_set_list) ]) return find_unique_id(cib, id) def have_duplicate_resource_sets(element, other_element): get_id_set_list = lambda element: [ resource_set.get_resource_id_set_list(resource_set_item) for resource_set_item in element.findall(".//resource_set") ] return get_id_set_list(element) == get_id_set_list(other_element) def check_is_without_duplication( report_processor, constraint_section, element, are_duplicate, export_element, duplication_alowed=False ): duplicate_element_list = [ duplicate_element for duplicate_element in constraint_section.findall(".//"+element.tag) if( element is not duplicate_element and are_duplicate(element, duplicate_element) ) ] if not duplicate_element_list: return report_processor.process(reports.duplicate_constraints_exist( element.tag, [ export_element(duplicate_element) for duplicate_element in duplicate_element_list ], ReportItemSeverity.WARNING if duplication_alowed else ReportItemSeverity.ERROR, forceable=None if duplication_alowed else report_codes.FORCE_CONSTRAINT_DUPLICATE, )) def create_with_set(constraint_section, tag_name, options, resource_set_list): if not resource_set_list: raise LibraryError(reports.empty_resource_set_list()) element = etree.SubElement(constraint_section, tag_name) element.attrib.update(options) for resource_set_item in resource_set_list: resource_set.create(element, resource_set_item) return element pcs-0.9.155/pcs/lib/cib/constraint/order.py000066400000000000000000000027651301012375000204230ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from functools import partial from pcs.lib import reports from pcs.lib.cib.constraint import constraint from pcs.lib.cib.tools import check_new_id_applicable from pcs.lib.errors import LibraryError TAG_NAME = "rsc_order" DESCRIPTION = "constraint id" ATTRIB = { "symmetrical": ("true", "false"), "kind": ("Optional", "Mandatory", "Serialize"), } def prepare_options_with_set(cib, options, resource_set_list): options = constraint.prepare_options( tuple(ATTRIB.keys()), options, create_id=partial( constraint.create_id, cib, TAG_NAME, resource_set_list ), validate_id=partial(check_new_id_applicable, cib, DESCRIPTION), ) report_items = [] if "kind" in options: kind = options["kind"].lower().capitalize() if kind not in ATTRIB["kind"]: report_items.append(reports.invalid_option_value( "kind", options["kind"], ATTRIB["kind"] )) options["kind"] = kind if "symmetrical" in options: symmetrical = options["symmetrical"].lower() if symmetrical not in ATTRIB["symmetrical"]: report_items.append(reports.invalid_option_value( "symmetrical", options["symmetrical"], ATTRIB["symmetrical"] )) options["symmetrical"] = symmetrical if report_items: raise LibraryError(*report_items) return options pcs-0.9.155/pcs/lib/cib/constraint/resource_set.py000066400000000000000000000041311301012375000217770ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from lxml import etree from pcs.lib import reports from pcs.lib.cib.tools import ( find_unique_id, export_attributes, ) from pcs.lib.errors import LibraryError ATTRIB = { "sequential": ("true", "false"), "require-all":("true", "false"), "action" : ("start", "promote", "demote", "stop"), "role" : ("Stopped", "Started", "Master", "Slave"), } def prepare_set(find_valid_id, resource_set): """return resource_set with corrected ids""" validate_options(resource_set["options"]) return { "ids": [find_valid_id(id) for id in resource_set["ids"]], "options": resource_set["options"] } def validate_options(options): #Pacemaker does not care currently about meaningfulness for concrete #constraint, so we use all attribs. for name, value in options.items(): if name not in ATTRIB: raise LibraryError( reports.invalid_option(name, list(ATTRIB.keys()), None) ) if value not in ATTRIB[name]: raise LibraryError( reports.invalid_option_value(name, value, ATTRIB[name]) ) def extract_id_set_list(resource_set_list): return [resource_set["ids"] for resource_set in resource_set_list] def create(parent, resource_set): """ parent - lxml element for append new resource_set """ element = etree.SubElement(parent, "resource_set") element.attrib.update(resource_set["options"]) element.attrib["id"] = find_unique_id( parent.getroottree(), "pcs_rsc_set_{0}".format("_".join(resource_set["ids"])) ) for id in resource_set["ids"]: etree.SubElement(element, "resource_ref").attrib["id"] = id return element def get_resource_id_set_list(element): return [ resource_ref_element.attrib["id"] for resource_ref_element in element.findall(".//resource_ref") ] def export(element): return { "ids": get_resource_id_set_list(element), "options": export_attributes(element), } pcs-0.9.155/pcs/lib/cib/constraint/ticket.py000066400000000000000000000110101301012375000205520ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from functools import partial from lxml import etree from pcs.lib import reports from pcs.lib.cib.constraint import constraint from pcs.lib.cib import tools from pcs.lib.errors import LibraryError TAG_NAME = 'rsc_ticket' DESCRIPTION = "constraint id" ATTRIB = { "loss-policy": ("fence", "stop", "freeze", "demote"), "ticket": None, } ATTRIB_PLAIN = { "rsc": None, "rsc-role": ("Stopped", "Started", "Master", "Slave"), } def _validate_options_common(options): report = [] if "loss-policy" in options: loss_policy = options["loss-policy"].lower() if options["loss-policy"] not in ATTRIB["loss-policy"]: report.append(reports.invalid_option_value( "loss-policy", options["loss-policy"], ATTRIB["loss-policy"] )) options["loss-policy"] = loss_policy return report def _create_id(cib, ticket, resource_id, resource_role): return tools.find_unique_id( cib, "-".join(('ticket', ticket, resource_id)) +("-{0}".format(resource_role) if resource_role else "") ) def prepare_options_with_set(cib, options, resource_set_list): options = constraint.prepare_options( tuple(ATTRIB.keys()), options, create_id=partial( constraint.create_id, cib, TAG_NAME, resource_set_list ), validate_id=partial(tools.check_new_id_applicable, cib, DESCRIPTION), ) report = _validate_options_common(options) if "ticket" not in options or not options["ticket"].strip(): report.append(reports.required_option_is_missing('ticket')) if report: raise LibraryError(*report) return options def prepare_options_plain(cib, options, ticket, resource_id): options = options.copy() report = _validate_options_common(options) if not ticket: report.append(reports.required_option_is_missing('ticket')) options["ticket"] = ticket if not resource_id: report.append(reports.required_option_is_missing('rsc')) options["rsc"] = resource_id if "rsc-role" in options: if options["rsc-role"]: resource_role = options["rsc-role"].lower().capitalize() if resource_role not in ATTRIB_PLAIN["rsc-role"]: report.append(reports.invalid_option_value( "rsc-role", options["rsc-role"], ATTRIB_PLAIN["rsc-role"] )) options["rsc-role"] = resource_role else: del(options["rsc-role"]) if report: raise LibraryError(*report) return constraint.prepare_options( tuple(list(ATTRIB) + list(ATTRIB_PLAIN)), options, partial( _create_id, cib, options["ticket"], resource_id, options.get("rsc-role", "") ), partial(tools.check_new_id_applicable, cib, DESCRIPTION) ) def create_plain(constraint_section, options): element = etree.SubElement(constraint_section, TAG_NAME) element.attrib.update(options) return element def remove_plain(constraint_section, ticket_key, resource_id): ticket_element_list = constraint_section.xpath( './/rsc_ticket[@ticket="{0}" and @rsc="{1}"]' .format(ticket_key, resource_id) ) for ticket_element in ticket_element_list: ticket_element.getparent().remove(ticket_element) return len(ticket_element_list) > 0 def remove_with_resource_set(constraint_section, ticket_key, resource_id): ref_element_list = constraint_section.xpath( './/rsc_ticket[@ticket="{0}"]/resource_set/resource_ref[@id="{1}"]' .format(ticket_key, resource_id) ) for ref_element in ref_element_list: set_element = ref_element.getparent() set_element.remove(ref_element) if not len(set_element): ticket_element = set_element.getparent() ticket_element.remove(set_element) if not len(ticket_element): ticket_element.getparent().remove(ticket_element) return len(ref_element_list) > 0 def are_duplicate_plain(element, other_element): return all( element.attrib.get(name, "") == other_element.attrib.get(name, "") for name in ("ticket", "rsc", "rsc-role") ) def are_duplicate_with_resource_set(element, other_element): return ( element.attrib["ticket"] == other_element.attrib["ticket"] and constraint.have_duplicate_resource_sets(element, other_element) ) pcs-0.9.155/pcs/lib/cib/nvpair.py000066400000000000000000000051641301012375000164170ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from lxml import etree from pcs.lib.cib.tools import ( get_sub_element, create_subelement_id, ) def set_nvpair_in_nvset(nvset_element, name, value): """ Update nvpair, create new if it doesn't yet exist or remove existing nvpair if value is empty. nvset_element -- element in which nvpair should be added/updated/removed name -- name of nvpair value -- value of nvpair """ nvpair = nvset_element.find("./nvpair[@name='{0}']".format(name)) if nvpair is None: if value: etree.SubElement( nvset_element, "nvpair", id=create_subelement_id(nvset_element, name), name=name, value=value ) else: if value: nvpair.set("value", value) else: nvset_element.remove(nvpair) def arrange_first_nvset(tag_name, context_element, attribute_dict): """ Arrange to context_element contains some nvset (with tag_name) with nvpairs corresponing to attribute_dict. WARNING: does not solve multiple nvset (with tag_name) under context_element! Consider carefully if this is your case. Probably not. There could be more than one nvset. This function is DEPRECATED. Try to use update_nvset etc. This method updates nvset specified by tag_name. If specified nvset doesn't exist it will be created. Returns updated nvset element or None if attribute_dict is empty. tag_name -- tag name of nvset element context_element -- parent element of nvset attribute_dict -- dictionary of nvpairs """ if not attribute_dict: return nvset_element = get_sub_element( context_element, tag_name, create_subelement_id(context_element, tag_name), new_index=0 ) update_nvset(nvset_element, attribute_dict) def update_nvset(nvset_element, attribute_dict): for name, value in sorted(attribute_dict.items()): set_nvpair_in_nvset(nvset_element, name, value) def get_nvset(nvset): """ Returns nvset element as list of nvpairs with format: [ { "id": , "name": , "value": }, ... ] nvset -- nvset element """ nvpair_list = [] for nvpair in nvset.findall("./nvpair"): nvpair_list.append({ "id": nvpair.get("id"), "name": nvpair.get("name"), "value": nvpair.get("value", "") }) return nvpair_list pcs-0.9.155/pcs/lib/cib/resource.py000066400000000000000000000005701301012375000167430ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) TAGS_CLONE = "clone", "master" TAGS_ALL = TAGS_CLONE + ("primitive", "group") def find_by_id(tree, id): for element in tree.findall('.//*[@id="{0}"]'.format(id)): if element is not None and element.tag in TAGS_ALL: return element return None pcs-0.9.155/pcs/lib/cib/test/000077500000000000000000000000001301012375000155175ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/cib/test/__init__.py000066400000000000000000000000001301012375000176160ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/cib/test/test_alert.py000066400000000000000000001161621301012375000202460ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from lxml import etree from pcs.common import report_codes from pcs.lib.cib import alert from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import( assert_raise_library_error, assert_xml_equal, assert_report_item_list_equal, ) from pcs.test.tools.custom_mock import MockLibraryReportProcessor class UpdateOptionalAttributeTest(TestCase): def test_add(self): element = etree.Element("element") alert._update_optional_attribute(element, "attr", "value1") self.assertEqual(element.get("attr"), "value1") def test_update(self): element = etree.Element("element", attr="value") alert._update_optional_attribute(element, "attr", "value1") self.assertEqual(element.get("attr"), "value1") def test_remove(self): element = etree.Element("element", attr="value") alert._update_optional_attribute(element, "attr", "") self.assertTrue(element.get("attr") is None) class GetAlertByIdTest(TestCase): def test_found(self): xml = """ """ assert_xml_equal( '', etree.tostring( alert.get_alert_by_id(etree.XML(xml), "alert-2") ).decode() ) def test_different_place(self): xml = """ """ assert_raise_library_error( lambda: alert.get_alert_by_id(etree.XML(xml), "alert-2"), ( severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, {"alert": "alert-2"} ) ) def test_not_exist(self): xml = """ """ assert_raise_library_error( lambda: alert.get_alert_by_id(etree.XML(xml), "alert-2"), ( severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, {"alert": "alert-2"} ) ) class GetRecipientByIdTest(TestCase): def setUp(self): self.xml = etree.XML( """ """ ) def test_exist(self): assert_xml_equal( '', etree.tostring( alert.get_recipient_by_id(self.xml, "rec-1") ).decode() ) def test_different_place(self): assert_raise_library_error( lambda: alert.get_recipient_by_id(self.xml, "rec-4"), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "rec-4", "id_description": "Recipient" } ) ) def test_not_in_alert(self): assert_raise_library_error( lambda: alert.get_recipient_by_id(self.xml, "rec-2"), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "rec-2", "id_description": "Recipient" } ) ) def test_not_recipient(self): assert_raise_library_error( lambda: alert.get_recipient_by_id(self.xml, "rec-3"), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "rec-3", "id_description": "Recipient" } ) ) class EnsureRecipientValueIsUniqueTest(TestCase): def setUp(self): self.mock_reporter = MockLibraryReportProcessor() self.alert = etree.Element("alert", id="alert-1") self.recipient = etree.SubElement( self.alert, "recipient", id="rec-1", value="value1" ) def test_is_unique_no_duplicity_allowed(self): alert.ensure_recipient_value_is_unique( self.mock_reporter, self.alert, "value2" ) self.assertEqual(0, len(self.mock_reporter.report_item_list)) def test_same_recipient_no_duplicity_allowed(self): alert.ensure_recipient_value_is_unique( self.mock_reporter, self.alert, "value1", recipient_id="rec-1" ) self.assertEqual(0, len(self.mock_reporter.report_item_list)) def test_same_recipient_duplicity_allowed(self): alert.ensure_recipient_value_is_unique( self.mock_reporter, self.alert, "value1", recipient_id="rec-1", allow_duplicity=True ) self.assertEqual(0, len(self.mock_reporter.report_item_list)) def test_not_unique_no_duplicity_allowed(self): report_item = ( severities.ERROR, report_codes.CIB_ALERT_RECIPIENT_ALREADY_EXISTS, { "alert": "alert-1", "recipient": "value1" }, report_codes.FORCE_ALERT_RECIPIENT_VALUE_NOT_UNIQUE ) assert_raise_library_error( lambda: alert.ensure_recipient_value_is_unique( self.mock_reporter, self.alert, "value1" ), report_item ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [report_item] ) def test_is_unique_duplicity_allowed(self): alert.ensure_recipient_value_is_unique( self.mock_reporter, self.alert, "value2", allow_duplicity=True ) self.assertEqual(0, len(self.mock_reporter.report_item_list)) def test_not_unique_duplicity_allowed(self): alert.ensure_recipient_value_is_unique( self.mock_reporter, self.alert, "value1", allow_duplicity=True ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [( severities.WARNING, report_codes.CIB_ALERT_RECIPIENT_ALREADY_EXISTS, { "alert": "alert-1", "recipient": "value1" } )] ) class CreateAlertTest(TestCase): def setUp(self): self.tree = etree.XML( """ """ ) def test_no_alerts(self): tree = etree.XML( """ """ ) assert_xml_equal( '', etree.tostring( alert.create_alert(tree, "my-alert", "/test/path") ).decode() ) assert_xml_equal( """ """, etree.tostring(tree).decode() ) def test_alerts_exists(self): assert_xml_equal( '', etree.tostring( alert.create_alert(self.tree, "my-alert", "/test/path") ).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) def test_alerts_exists_with_description(self): assert_xml_equal( '', etree.tostring(alert.create_alert( self.tree, "my-alert", "/test/path", "nothing" )).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) def test_invalid_id(self): assert_raise_library_error( lambda: alert.create_alert(self.tree, "1alert", "/path"), ( severities.ERROR, report_codes.INVALID_ID, { "id": "1alert", "id_description": "alert-id", "invalid_character": "1", "is_first_char": True, } ) ) def test_id_exists(self): assert_raise_library_error( lambda: alert.create_alert(self.tree, "alert", "/path"), ( severities.ERROR, report_codes.ID_ALREADY_EXISTS, {"id": "alert"} ) ) def test_no_id(self): assert_xml_equal( '', etree.tostring( alert.create_alert(self.tree, None, "/test/path") ).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) class UpdateAlertTest(TestCase): def setUp(self): self.tree = etree.XML( """ """ ) def test_update_path(self): assert_xml_equal( '', etree.tostring( alert.update_alert(self.tree, "alert", "/test/path") ).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) def test_remove_path(self): assert_xml_equal( '', etree.tostring(alert.update_alert(self.tree, "alert", "")).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) def test_update_description(self): assert_xml_equal( '', etree.tostring( alert.update_alert(self.tree, "alert", None, "desc") ).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) def test_remove_description(self): assert_xml_equal( '', etree.tostring( alert.update_alert(self.tree, "alert1", None, "") ).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) def test_id_not_exists(self): assert_raise_library_error( lambda: alert.update_alert(self.tree, "alert0", "/test"), ( severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, {"alert": "alert0"} ) ) class RemoveAlertTest(TestCase): def setUp(self): self.tree = etree.XML( """ """ ) def test_success(self): alert.remove_alert(self.tree, "alert") assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) def test_not_existing_id(self): assert_raise_library_error( lambda: alert.remove_alert(self.tree, "not-existing-id"), ( severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, {"alert": "not-existing-id"} ) ) class AddRecipientTest(TestCase): def setUp(self): self.mock_reporter = MockLibraryReportProcessor() self.tree = etree.XML( """ """ ) def test_with_id(self): assert_xml_equal( '', etree.tostring( alert.add_recipient( self.mock_reporter, self.tree, "alert", "value1", "my-recipient" ) ).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) self.assertEqual([], self.mock_reporter.report_item_list) def test_without_id(self): assert_xml_equal( '', etree.tostring( alert.add_recipient( self.mock_reporter, self.tree, "alert", "value1" ) ).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) self.assertEqual([], self.mock_reporter.report_item_list) def test_id_exists(self): assert_raise_library_error( lambda: alert.add_recipient( self.mock_reporter, self.tree, "alert", "value1", "alert-recipient" ), ( severities.ERROR, report_codes.ID_ALREADY_EXISTS, {"id": "alert-recipient"} ) ) self.assertEqual([], self.mock_reporter.report_item_list) def test_duplicity_of_value_not_allowed(self): report_item = ( severities.ERROR, report_codes.CIB_ALERT_RECIPIENT_ALREADY_EXISTS, { "alert": "alert", "recipient": "test_val" }, report_codes.FORCE_ALERT_RECIPIENT_VALUE_NOT_UNIQUE ) assert_raise_library_error( lambda: alert.add_recipient( self.mock_reporter, self.tree, "alert", "test_val" ), report_item ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [report_item] ) def test_duplicity_of_value_allowed(self): assert_xml_equal( '', etree.tostring( alert.add_recipient( self.mock_reporter, self.tree, "alert", "test_val", allow_same_value=True ) ).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [( severities.WARNING, report_codes.CIB_ALERT_RECIPIENT_ALREADY_EXISTS, { "alert": "alert", "recipient": "test_val" } )] ) def test_alert_not_exist(self): assert_raise_library_error( lambda: alert.add_recipient( self.mock_reporter, self.tree, "alert1", "test_val" ), ( severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, {"alert": "alert1"} ) ) def test_with_description(self): assert_xml_equal( """ """, etree.tostring(alert.add_recipient( self.mock_reporter, self.tree, "alert", "value1", description="desc" )).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) self.assertEqual([], self.mock_reporter.report_item_list) class UpdateRecipientTest(TestCase): def setUp(self): self.mock_reporter = MockLibraryReportProcessor() self.tree = etree.XML( """ """ ) def test_update_value(self): assert_xml_equal( """ """, etree.tostring(alert.update_recipient( self.mock_reporter, self.tree, "alert-recipient", recipient_value="new_val" )).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) self.assertEqual([], self.mock_reporter.report_item_list) def test_update_same_value_no_duplicity_allowed(self): assert_xml_equal( '', etree.tostring(alert.update_recipient( self.mock_reporter, self.tree, "alert-recipient", recipient_value="test_val" )).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) self.assertEqual([], self.mock_reporter.report_item_list) def test_update_same_value_duplicity_allowed(self): assert_xml_equal( '', etree.tostring(alert.update_recipient( self.mock_reporter, self.tree, "alert-recipient", recipient_value="test_val", allow_same_value=True )).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) self.assertEqual([], self.mock_reporter.report_item_list) def test_duplicity_of_value_not_allowed(self): report_item = ( severities.ERROR, report_codes.CIB_ALERT_RECIPIENT_ALREADY_EXISTS, { "alert": "alert", "recipient": "value1" }, report_codes.FORCE_ALERT_RECIPIENT_VALUE_NOT_UNIQUE ) assert_raise_library_error( lambda: alert.update_recipient( self.mock_reporter, self.tree, "alert-recipient", "value1" ), report_item ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [report_item] ) def test_duplicity_of_value_allowed(self): assert_xml_equal( """ """, etree.tostring(alert.update_recipient( self.mock_reporter, self.tree, "alert-recipient", recipient_value="value1", allow_same_value=True )).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) assert_report_item_list_equal( self.mock_reporter.report_item_list, [( severities.WARNING, report_codes.CIB_ALERT_RECIPIENT_ALREADY_EXISTS, { "alert": "alert", "recipient": "value1" } )] ) def test_add_description(self): assert_xml_equal( """ """, etree.tostring(alert.update_recipient( self.mock_reporter, self.tree, "alert-recipient", description="description" )).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) self.assertEqual([], self.mock_reporter.report_item_list) def test_update_description(self): assert_xml_equal( """ """, etree.tostring(alert.update_recipient( self.mock_reporter, self.tree, "alert-recipient-1", description="description" )).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) self.assertEqual([], self.mock_reporter.report_item_list) def test_remove_description(self): assert_xml_equal( """ """, etree.tostring( alert.update_recipient( self.mock_reporter, self.tree, "alert-recipient-1", description="" ) ).decode() ) assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) self.assertEqual([], self.mock_reporter.report_item_list) def test_recipient_not_exists(self): assert_raise_library_error( lambda: alert.update_recipient( self.mock_reporter, self.tree, "recipient"), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "recipient", "id_description": "Recipient" } ) ) class RemoveRecipientTest(TestCase): def setUp(self): self.tree = etree.XML( """ """ ) def test_success(self): alert.remove_recipient(self.tree, "alert-recipient-2") assert_xml_equal( """ """, etree.tostring(self.tree).decode() ) def test_recipient_not_exists(self): assert_raise_library_error( lambda: alert.remove_recipient(self.tree, "recipient"), ( severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "recipient", "id_description": "Recipient" } ) ) class GetAllRecipientsTest(TestCase): def test_success(self): alert_obj = etree.XML( """ """ ) self.assertEqual( [ { "id": "alert-recipient", "value": "test_val", "description": "", "instance_attributes": [ { "id": "nvset-name1-value1", "name": "name1", "value": "value1" }, { "id": "nvset-name2-value2", "name": "name2", "value": "value2" } ], "meta_attributes": [ { "id": "nvset-name3", "name": "name3", "value": "" } ] }, { "id": "alert-recipient-1", "value": "value1", "description": "desc", "instance_attributes": [], "meta_attributes": [] } ], alert.get_all_recipients(alert_obj) ) class GetAllAlertsTest(TestCase): def test_success(self): alerts = etree.XML( """ """ ) self.assertEqual( [ { "id": "alert", "path": "/path", "description": "", "instance_attributes": [], "meta_attributes": [], "recipient_list": [ { "id": "alert-recipient", "value": "test_val", "description": "", "instance_attributes": [ { "id": "instance_attributes-name1-value1", "name": "name1", "value": "value1" }, { "id": "instance_attributes-name2-value2", "name": "name2", "value": "value2" } ], "meta_attributes": [ { "id": "meta_attributes-name3", "name": "name3", "value": "" } ] }, { "id": "alert-recipient-1", "value": "value1", "description": "desc", "instance_attributes": [], "meta_attributes": [] } ] }, { "id": "alert1", "path": "/test/path", "description": "desc", "instance_attributes": [ { "id": "alert1-name1-value1", "name": "name1", "value": "value1" }, { "id": "alert1-name2-value2", "name": "name2", "value": "value2" } ], "meta_attributes": [ { "id": "alert1-name3", "name": "name3", "value": "" } ], "recipient_list": [] } ], alert.get_all_alerts(alerts) ) pcs-0.9.155/pcs/lib/cib/test/test_constraint.py000066400000000000000000000243461301012375000213250ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from functools import partial from pcs.test.tools.pcs_unittest import TestCase from lxml import etree from pcs.common import report_codes from pcs.lib.cib.constraint import constraint from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import( assert_raise_library_error, assert_xml_equal, ) from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.test.tools.pcs_unittest import mock from pcs.test.tools.assertions import ( assert_report_item_list_equal, ) def fixture_element(tag, id): element = mock.MagicMock() element.tag = tag element.attrib = {"id": id} return element @mock.patch("pcs.lib.cib.constraint.constraint.find_parent") @mock.patch("pcs.lib.cib.constraint.constraint.resource.find_by_id") class FindValidResourceId(TestCase): def setUp(self): self.cib = "cib" self.report_processor = MockLibraryReportProcessor() self.find = partial( constraint.find_valid_resource_id, self.report_processor, self.cib, can_repair_to_clone=False, in_clone_allowed=False, ) def test_raises_when_element_not_found(self, mock_find_by_id, _): mock_find_by_id.return_value = None assert_raise_library_error( lambda: self.find(id="resourceA"), ( severities.ERROR, report_codes.RESOURCE_DOES_NOT_EXIST, {"resource_id": "resourceA"} ), ) def test_return_same_id_when_resource_is_clone(self, mock_find_by_id, _): mock_find_by_id.return_value = fixture_element("clone", "resourceA") self.assertEqual("resourceA", self.find(id="resourceA")) def test_return_same_id_when_is_primitive_but_not_in_clone( self, mock_find_by_id, mock_find_parent ): mock_find_by_id.return_value = fixture_element("primitive", "resourceA") mock_find_parent.return_value = None self.assertEqual("resourceA", self.find(id="resourceA")) def test_refuse_when_resource_is_in_clone( self, mock_find_by_id, mock_find_parent ): mock_find_by_id.return_value = fixture_element("primitive", "resourceA") mock_find_parent.return_value = fixture_element("clone", "clone_id") assert_raise_library_error( lambda: self.find(id="resourceA"), ( severities.ERROR, report_codes.RESOURCE_FOR_CONSTRAINT_IS_MULTIINSTANCE, { "resource_id": "resourceA", "parent_type": "clone", "parent_id": "clone_id", }, report_codes.FORCE_CONSTRAINT_MULTIINSTANCE_RESOURCE ), ) def test_return_clone_id_when_repair_allowed( self, mock_find_by_id, mock_find_parent ): mock_find_by_id.return_value = fixture_element("primitive", "resourceA") mock_find_parent.return_value = fixture_element("clone", "clone_id") self.assertEqual( "clone_id", self.find(can_repair_to_clone=True, id="resourceA") ) assert_report_item_list_equal( self.report_processor.report_item_list, [] ) def test_return_resource_id_when_in_clone_allowed( self, mock_find_by_id, mock_find_parent ): mock_find_by_id.return_value = fixture_element("primitive", "resourceA") mock_find_parent.return_value = fixture_element("clone", "clone_id") self.assertEqual( "resourceA", self.find(in_clone_allowed=True, id="resourceA") ) assert_report_item_list_equal(self.report_processor.report_item_list, [( severities.WARNING, report_codes.RESOURCE_FOR_CONSTRAINT_IS_MULTIINSTANCE, { "resource_id": "resourceA", "parent_type": "clone", "parent_id": "clone_id", }, )]) class PrepareOptionsTest(TestCase): def test_refuse_unknown_option(self): assert_raise_library_error( lambda: constraint.prepare_options( ("a", ), {"b": "c"}, mock.MagicMock(), mock.MagicMock() ), ( severities.ERROR, report_codes.INVALID_OPTION, { "option_name": "b", "option_type": None, "allowed": ["a", "id"], } ), ) def test_complete_id(self): mock_create_id = mock.MagicMock() mock_create_id.return_value = "new-id" self.assertEqual({"id": "new-id"}, constraint.prepare_options( ("a",), {}, mock_create_id, mock.MagicMock() )) def test_has_no_side_efect_on_input_options(self): mock_create_id = mock.MagicMock() mock_create_id.return_value = "new-id" options = {"a": "b"} self.assertEqual( {"id": "new-id", "a": "b"}, constraint.prepare_options( ("a",), options, mock_create_id, mock.MagicMock() ) ) self.assertEqual({"a": "b"}, options) def test_refuse_invalid_id(self): class SomeException(Exception): pass mock_validate_id = mock.MagicMock() mock_validate_id.side_effect = SomeException() self.assertRaises( SomeException, lambda: constraint.prepare_options( ("a", ), {"id": "invalid"}, mock.MagicMock(), mock_validate_id ), ) mock_validate_id.assert_called_once_with("invalid") class CreateIdTest(TestCase): @mock.patch( "pcs.lib.cib.constraint.constraint.resource_set.extract_id_set_list" ) @mock.patch("pcs.lib.cib.constraint.constraint.find_unique_id") def test_create_id_from_resource_set_list(self, mock_find_id, mock_extract): mock_extract.return_value = [["A", "B"], ["C"]] mock_find_id.return_value = "some_id" self.assertEqual( "some_id", constraint.create_id("cib", "PREFIX", "resource_set_list") ) mock_extract.assert_called_once_with("resource_set_list") mock_find_id.assert_called_once_with("cib", "pcs_PREFIX_set_A_B_set_C") def fixture_constraint_section(return_value): constraint_section = mock.MagicMock() constraint_section.findall = mock.MagicMock() constraint_section.findall.return_value = return_value return constraint_section @mock.patch("pcs.lib.cib.constraint.constraint.export_with_set") class CheckIsWithoutDuplicationTest(TestCase): def test_raises_when_duplicate_element_found(self, export_with_set): export_with_set.return_value = "exported_duplicate_element" element = mock.MagicMock() element.tag = "constraint_type" report_processor = MockLibraryReportProcessor() assert_raise_library_error( lambda: constraint.check_is_without_duplication( report_processor, fixture_constraint_section(["duplicate_element"]), element, are_duplicate=lambda e1, e2: True, export_element=constraint.export_with_set, ), ( severities.ERROR, report_codes.DUPLICATE_CONSTRAINTS_EXIST, { 'constraint_info_list': ['exported_duplicate_element'], 'constraint_type': 'constraint_type' }, report_codes.FORCE_CONSTRAINT_DUPLICATE ), ) def test_success_when_no_duplication_found(self, export_with_set): export_with_set.return_value = "exported_duplicate_element" element = mock.MagicMock() element.tag = "constraint_type" #no exception raised report_processor = MockLibraryReportProcessor() constraint.check_is_without_duplication( report_processor, fixture_constraint_section([]), element, are_duplicate=lambda e1, e2: True, export_element=constraint.export_with_set, ) def test_report_when_duplication_allowed(self, export_with_set): export_with_set.return_value = "exported_duplicate_element" element = mock.MagicMock() element.tag = "constraint_type" report_processor = MockLibraryReportProcessor() constraint.check_is_without_duplication( report_processor, fixture_constraint_section(["duplicate_element"]), element, are_duplicate=lambda e1, e2: True, export_element=constraint.export_with_set, duplication_alowed=True, ) assert_report_item_list_equal( report_processor.report_item_list, [ ( severities.WARNING, report_codes.DUPLICATE_CONSTRAINTS_EXIST, { 'constraint_info_list': ['exported_duplicate_element'], 'constraint_type': 'constraint_type' }, ) ] ) class CreateWithSetTest(TestCase): def test_put_new_constraint_to_constraint_section(self): constraint_section = etree.Element("constraints") constraint.create_with_set( constraint_section, "ticket", {"a": "b"}, [{"ids": ["A", "B"], "options": {"c": "d"}}] ) assert_xml_equal(etree.tostring(constraint_section).decode(), """ """) def test_refuse_empty_resource_set_list(self): constraint_section = etree.Element("constraints") assert_raise_library_error( lambda: constraint.create_with_set( constraint_section, "ticket", {"a": "b"}, [] ), (severities.ERROR, report_codes.EMPTY_RESOURCE_SET_LIST, {}) ) pcs-0.9.155/pcs/lib/cib/test/test_constraint_colocation.py000066400000000000000000000063151301012375000235330ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.common import report_codes from pcs.lib.cib.constraint import colocation from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import assert_raise_library_error from pcs.test.tools.pcs_unittest import mock #Patch check_new_id_applicable is always desired when working with #prepare_options_with_set. Patched function raises when id not applicable #and do nothing when applicable - in this case tests do no actions with it @mock.patch("pcs.lib.cib.constraint.colocation.check_new_id_applicable") class PrepareOptionsWithSetTest(TestCase): def setUp(self): self.cib = "cib" self.resource_set_list = "resource_set_list" self.prepare = lambda options: colocation.prepare_options_with_set( self.cib, options, self.resource_set_list, ) @mock.patch("pcs.lib.cib.constraint.colocation.constraint.create_id") def test_complete_id(self, mock_create_id, _): mock_create_id.return_value = "generated_id" options = {"score": "1"} expected_options = options.copy() expected_options.update({"id": "generated_id"}) self.assertEqual(expected_options, self.prepare(options)) mock_create_id.assert_called_once_with( self.cib, colocation.TAG_NAME, self.resource_set_list ) def test_refuse_invalid_id(self, mock_check_new_id_applicable): mock_check_new_id_applicable.side_effect = Exception() invalid_id = "invalid_id" self.assertRaises(Exception, lambda: self.prepare({ "score": "1", "id": invalid_id, })) mock_check_new_id_applicable.assert_called_once_with( self.cib, colocation.DESCRIPTION, invalid_id ) def test_refuse_bad_score(self, _): assert_raise_library_error( lambda: self.prepare({ "score": "bad", "id": "id", }), (severities.ERROR, report_codes.INVALID_SCORE, { 'score': 'bad' }), ) def test_refuse_more_scores(self, _): assert_raise_library_error( lambda: self.prepare({ "score": "1", "score-attribute": "2", "id": "id", }), (severities.ERROR, report_codes.MULTIPLE_SCORE_OPTIONS, {}), ) def test_refuse_unknown_attributes(self, _): assert_raise_library_error( lambda: self.prepare({ "score": "1", "unknown": "value", "id": "id", }), ( severities.ERROR, report_codes.INVALID_OPTION, { "option_name": "unknown", "option_type": None, "allowed": [ "id", "score", "score-attribute", "score-attribute-mangle", ], } ), ) pcs-0.9.155/pcs/lib/cib/test/test_constraint_order.py000066400000000000000000000067521301012375000225210ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.common import report_codes from pcs.lib.cib.constraint import order from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import assert_raise_library_error from pcs.test.tools.pcs_unittest import mock #Patch check_new_id_applicable is always desired when working with #prepare_options_with_set. Patched function raises when id not applicable #and do nothing when applicable - in this case tests do no actions with it @mock.patch("pcs.lib.cib.constraint.order.check_new_id_applicable") class PrepareOptionsWithSetTest(TestCase): def setUp(self): self.cib = "cib" self.resource_set_list = "resource_set_list" self.prepare = lambda options: order.prepare_options_with_set( self.cib, options, self.resource_set_list, ) @mock.patch("pcs.lib.cib.constraint.order.constraint.create_id") def test_complete_id(self, mock_create_id, _): mock_create_id.return_value = "generated_id" options = {"symmetrical": "true", "kind": "Optional"} expected_options = options.copy() expected_options.update({"id": "generated_id"}) self.assertEqual(expected_options, self.prepare(options)) mock_create_id.assert_called_once_with( self.cib, order.TAG_NAME, self.resource_set_list ) def test_refuse_invalid_id(self, mock_check_new_id_applicable): mock_check_new_id_applicable.side_effect = Exception() invalid_id = "invalid_id" self.assertRaises(Exception, lambda: self.prepare({ "symmetrical": "true", "kind": "Optional", "id": invalid_id, })) mock_check_new_id_applicable.assert_called_once_with( self.cib, order.DESCRIPTION, invalid_id ) def test_refuse_unknown_kind(self, _): assert_raise_library_error( lambda: self.prepare({ "symmetrical": "true", "kind": "unknown", "id": "id", }), (severities.ERROR, report_codes.INVALID_OPTION_VALUE, { 'allowed_values': ('Optional', 'Mandatory', 'Serialize'), 'option_value': 'unknown', 'option_name': 'kind', }), ) def test_refuse_unknown_symmetrical(self, _): assert_raise_library_error( lambda: self.prepare({ "symmetrical": "unknown", "kind": "Optional", "id": "id", }), (severities.ERROR, report_codes.INVALID_OPTION_VALUE, { 'allowed_values': ('true', 'false'), 'option_value': 'unknown', 'option_name': 'symmetrical', }), ) def test_refuse_unknown_attributes(self, _): assert_raise_library_error( lambda: self.prepare({ "symmetrical": "unknown", "kind": "Optional", "unknown": "value", "id": "id", }), ( severities.ERROR, report_codes.INVALID_OPTION, { "option_name": "unknown", "option_type": None, "allowed": [ "id", "kind", "symmetrical"], } ), ) pcs-0.9.155/pcs/lib/cib/test/test_constraint_ticket.py000066400000000000000000000347761301012375000227000ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from functools import partial from pcs.test.tools.pcs_unittest import TestCase from lxml import etree from pcs.common import report_codes from pcs.lib.cib.constraint import ticket from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import ( assert_raise_library_error, assert_xml_equal, ) from pcs.test.tools.pcs_unittest import mock @mock.patch("pcs.lib.cib.constraint.ticket.tools.check_new_id_applicable") class PrepareOptionsPlainTest(TestCase): def setUp(self): self.cib = "cib" self.prepare = partial(ticket.prepare_options_plain, self.cib) @mock.patch("pcs.lib.cib.constraint.ticket._create_id") def test_prepare_correct_options(self, mock_create_id, _): mock_create_id.return_value = "generated_id" self.assertEqual( { 'id': 'generated_id', 'loss-policy': 'fence', 'rsc': 'resourceA', 'rsc-role': 'Master', 'ticket': 'ticket_key' }, self.prepare( {"loss-policy": "fence", "rsc-role": "master"}, "ticket_key", "resourceA", ) ) @mock.patch("pcs.lib.cib.constraint.ticket._create_id") def test_does_not_include_role_if_not_presented(self, mock_create_id, _): mock_create_id.return_value = "generated_id" self.assertEqual( { 'id': 'generated_id', 'loss-policy': 'fence', 'rsc': 'resourceA', 'ticket': 'ticket_key' }, self.prepare( {"loss-policy": "fence", "rsc-role": ""}, "ticket_key", "resourceA", ) ) def test_refuse_unknown_attributes(self, _): assert_raise_library_error( lambda: self.prepare( {"unknown": "nonsense", "rsc-role": "master"}, "ticket_key", "resourceA", ), ( severities.ERROR, report_codes.INVALID_OPTION, { "option_name": "unknown", "option_type": None, "allowed": ["id", "loss-policy", "rsc", "rsc-role", "ticket"], } ), ) def test_refuse_bad_role(self, _): assert_raise_library_error( lambda: self.prepare( {"id": "id", "rsc-role": "bad_role"}, "ticket_key", "resourceA" ), (severities.ERROR, report_codes.INVALID_OPTION_VALUE, { 'allowed_values': ('Stopped', 'Started', 'Master', 'Slave'), 'option_value': 'bad_role', 'option_name': 'rsc-role', }), ) def test_refuse_missing_ticket(self, _): assert_raise_library_error( lambda: self.prepare( {"id": "id", "rsc-role": "master"}, "", "resourceA" ), ( severities.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, { "option_name": "ticket" } ), ) def test_refuse_missing_resource_id(self, _): assert_raise_library_error( lambda: self.prepare( {"id": "id", "rsc-role": "master"}, "ticket_key", "" ), ( severities.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, { "option_name": "rsc", } ), ) def test_refuse_unknown_lost_policy(self, mock_check_new_id_applicable): assert_raise_library_error( lambda: self.prepare( { "loss-policy": "unknown", "ticket": "T", "id": "id"}, "ticket_key", "resourceA", ), (severities.ERROR, report_codes.INVALID_OPTION_VALUE, { 'allowed_values': ('fence', 'stop', 'freeze', 'demote'), 'option_value': 'unknown', 'option_name': 'loss-policy', }), ) @mock.patch("pcs.lib.cib.constraint.ticket._create_id") def test_complete_id(self, mock_create_id, _): mock_create_id.return_value = "generated_id" options = {"loss-policy": "freeze", "ticket": "T", "rsc-role": "Master"} ticket_key = "ticket_key" resource_id = "resourceA" expected_options = options.copy() expected_options.update({ "id": "generated_id", "rsc": resource_id, "rsc-role": "Master", "ticket": ticket_key, }) self.assertEqual(expected_options, self.prepare( options, ticket_key, resource_id, )) mock_create_id.assert_called_once_with( self.cib, ticket_key, resource_id, "Master", ) #Patch check_new_id_applicable is always desired when working with #prepare_options_with_set. Patched function raises when id not applicable #and do nothing when applicable - in this case tests do no actions with it @mock.patch("pcs.lib.cib.constraint.ticket.tools.check_new_id_applicable") class PrepareOptionsWithSetTest(TestCase): def setUp(self): self.cib = "cib" self.resource_set_list = "resource_set_list" self.prepare = lambda options: ticket.prepare_options_with_set( self.cib, options, self.resource_set_list, ) @mock.patch("pcs.lib.cib.constraint.ticket.constraint.create_id") def test_complete_id(self, mock_create_id, _): mock_create_id.return_value = "generated_id" options = {"loss-policy": "freeze", "ticket": "T"} expected_options = options.copy() expected_options.update({"id": "generated_id"}) self.assertEqual(expected_options, self.prepare(options)) mock_create_id.assert_called_once_with( self.cib, ticket.TAG_NAME, self.resource_set_list ) def test_refuse_invalid_id(self, mock_check_new_id_applicable): class SomeException(Exception): pass mock_check_new_id_applicable.side_effect = SomeException() invalid_id = "invalid_id" self.assertRaises(SomeException, lambda: self.prepare({ "loss-policy": "freeze", "ticket": "T", "id": invalid_id, })) mock_check_new_id_applicable.assert_called_once_with( self.cib, ticket.DESCRIPTION, invalid_id ) def test_refuse_unknown_lost_policy(self, _): assert_raise_library_error( lambda: self.prepare({ "loss-policy": "unknown", "ticket": "T", "id": "id", }), (severities.ERROR, report_codes.INVALID_OPTION_VALUE, { 'allowed_values': ('fence', 'stop', 'freeze', 'demote'), 'option_value': 'unknown', 'option_name': 'loss-policy', }), ) def test_refuse_missing_ticket(self, _): assert_raise_library_error( lambda: self.prepare({"loss-policy": "stop", "id": "id"}), ( severities.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, {"option_name": "ticket"} ) ) def test_refuse_empty_ticket(self, _): assert_raise_library_error( lambda: self.prepare({ "loss-policy": "stop", "id": "id", "ticket": " " }), ( severities.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, {"option_name": "ticket"} ) ) class Element(object): def __init__(self, attrib): self.attrib = attrib def update(self, attrib): self.attrib.update(attrib) return self class AreDuplicatePlain(TestCase): def setUp(self): self.first = Element({ "ticket": "ticket_key", "rsc": "resurceA", "rsc-role": "Master" }) self.second = Element({ "ticket": "ticket_key", "rsc": "resurceA", "rsc-role": "Master" }) def test_returns_true_for_duplicate_elements(self): self.assertTrue(ticket.are_duplicate_plain(self.first, self.second)) def test_returns_false_for_different_ticket(self): self.assertFalse(ticket.are_duplicate_plain( self.first, self.second.update({"ticket": "X"}) )) def test_returns_false_for_different_resource(self): self.assertFalse(ticket.are_duplicate_plain( self.first, self.second.update({"rsc": "Y"}) )) def test_returns_false_for_different_role(self): self.assertFalse(ticket.are_duplicate_plain( self.first, self.second.update({"rsc-role": "Z"}) )) def test_returns_false_for_different_elements(self): self.second.update({ "ticket": "X", "rsc": "Y", "rsc-role": "Z" }) self.assertFalse(ticket.are_duplicate_plain(self.first, self.second)) @mock.patch("pcs.lib.cib.constraint.ticket.constraint.have_duplicate_resource_sets") class AreDuplicateWithResourceSet(TestCase): def test_returns_true_for_duplicate_elements( self, mock_have_duplicate_resource_sets ): mock_have_duplicate_resource_sets.return_value = True self.assertTrue(ticket.are_duplicate_with_resource_set( Element({"ticket": "ticket_key"}), Element({"ticket": "ticket_key"}), )) def test_returns_false_for_different_elements( self, mock_have_duplicate_resource_sets ): mock_have_duplicate_resource_sets.return_value = True self.assertFalse(ticket.are_duplicate_with_resource_set( Element({"ticket": "ticket_key"}), Element({"ticket": "X"}), )) class RemovePlainTest(TestCase): def test_remove_tickets_constraints_for_resource(self): constraint_section = etree.fromstring(""" """) self.assertTrue(ticket.remove_plain( constraint_section, ticket_key="tA", resource_id="rA", )) assert_xml_equal(etree.tostring(constraint_section).decode(), """ """) def test_remove_nothing_when_no_matching_found(self): constraint_section = etree.fromstring(""" """) self.assertFalse(ticket.remove_plain( constraint_section, ticket_key="tA", resource_id="rA", )) assert_xml_equal(etree.tostring(constraint_section).decode(), """ """) class RemoveWithSetTest(TestCase): def test_remove_resource_references_and_empty_remaining_parents(self): constraint_section = etree.fromstring(""" """) self.assertTrue(ticket.remove_with_resource_set( constraint_section, ticket_key="tA", resource_id="rA" )) assert_xml_equal( """ """, etree.tostring(constraint_section).decode() ) def test_remove_nothing_when_no_matching_found(self): constraint_section = etree.fromstring(""" """) self.assertFalse(ticket.remove_with_resource_set( constraint_section, ticket_key="tA", resource_id="rA" )) pcs-0.9.155/pcs/lib/cib/test/test_nvpair.py000066400000000000000000000162161301012375000204350ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from lxml import etree from pcs.lib.cib import nvpair from pcs.test.tools.assertions import assert_xml_equal from pcs.test.tools.pcs_unittest import TestCase, mock class UpdateNvsetTest(TestCase): @mock.patch( "pcs.lib.cib.nvpair.create_subelement_id", mock.Mock(return_value="4") ) def test_updates_nvset(self): nvset_element = etree.fromstring(""" """) nvpair.update_nvset(nvset_element, { "a": "B", "c": "", "g": "h", }) assert_xml_equal( """ """, etree.tostring(nvset_element).decode() ) def test_empty_value_has_no_effect(self): xml = """ """ nvset_element = etree.fromstring(xml) nvpair.update_nvset(nvset_element, {}) assert_xml_equal(xml, etree.tostring(nvset_element).decode()) class SetNvpairInNvsetTest(TestCase): def setUp(self): self.nvset = etree.Element("nvset", id="nvset") etree.SubElement( self.nvset, "nvpair", id="nvset-attr", name="attr", value="1" ) etree.SubElement( self.nvset, "nvpair", id="nvset-attr2", name="attr2", value="2" ) etree.SubElement( self.nvset, "notnvpair", id="nvset-test", name="test", value="0" ) def test_update(self): nvpair.set_nvpair_in_nvset(self.nvset, "attr", "10") assert_xml_equal( """ """, etree.tostring(self.nvset).decode() ) def test_add(self): nvpair.set_nvpair_in_nvset(self.nvset, "test", "0") assert_xml_equal( """ """, etree.tostring(self.nvset).decode() ) def test_remove(self): nvpair.set_nvpair_in_nvset(self.nvset, "attr2", "") assert_xml_equal( """ """, etree.tostring(self.nvset).decode() ) def test_remove_not_existing(self): nvpair.set_nvpair_in_nvset(self.nvset, "attr3", "") assert_xml_equal( """ """, etree.tostring(self.nvset).decode() ) class ArrangeSomeNvsetTest(TestCase): def setUp(self): self.root = etree.Element("root", id="root") self.nvset = etree.SubElement(self.root, "nvset", id="nvset") etree.SubElement( self.nvset, "nvpair", id="nvset-attr", name="attr", value="1" ) etree.SubElement( self.nvset, "nvpair", id="nvset-attr2", name="attr2", value="2" ) etree.SubElement( self.nvset, "notnvpair", id="nvset-test", name="test", value="0" ) def test_empty_value_has_no_effect(self): nvpair.arrange_first_nvset("nvset", self.root, {}) assert_xml_equal( """ """, etree.tostring(self.nvset).decode() ) def test_update_existing_nvset(self): nvpair.arrange_first_nvset("nvset", self.root, { "attr": "10", "new_one": "20", "test": "0", "attr2": "" }) assert_xml_equal( """ """, etree.tostring(self.nvset).decode() ) def test_create_new_nvset_if_does_not_exist(self): root = etree.Element("root", id="root") nvpair.arrange_first_nvset("nvset", root, { "attr": "10", "new_one": "20", "test": "0", "attr2": "" }) assert_xml_equal( """ """, etree.tostring(root).decode() ) class GetNvsetTest(TestCase): def test_success(self): nvset = etree.XML( """ """ ) self.assertEqual( [ { "id": "nvset-name1", "name": "name1", "value": "value1" }, { "id": "nvset-name2", "name": "name2", "value": "value2" }, { "id": "nvset-name3", "name": "name3", "value": "" } ], nvpair.get_nvset(nvset) ) pcs-0.9.155/pcs/lib/cib/test/test_resource.py000066400000000000000000000010251301012375000207550ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from lxml import etree from pcs.lib.cib.resource import find_by_id class FindByIdTest(TestCase): def test_find_correct_tag(self): tree = etree.XML(""" """) element = find_by_id(tree, "A") self.assertEqual(element.tag, "primitive") pcs-0.9.155/pcs/lib/cib/test/test_resource_set.py000066400000000000000000000071721301012375000216410ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from lxml import etree from pcs.common import report_codes from pcs.lib.cib.constraint import resource_set from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import( assert_raise_library_error, assert_xml_equal ) from pcs.test.tools.pcs_unittest import mock class PrepareSetTest(TestCase): def test_return_corrected_resurce_set(self): find_valid_id = mock.Mock() find_valid_id.side_effect = lambda id: {"A": "AA", "B": "BB"}[id] self.assertEqual( {"ids": ["AA", "BB"], "options": {"sequential": "true"}}, resource_set.prepare_set(find_valid_id, { "ids": ["A", "B"], "options": {"sequential": "true"} }) ) def test_refuse_invalid_attribute_name(self): assert_raise_library_error( lambda: resource_set.prepare_set(mock.Mock(), { "ids": ["A", "B"], "options": {"invalid_name": "true"} }), ( severities.ERROR, report_codes.INVALID_OPTION, { "option_name": "invalid_name", "option_type": None, "allowed": ["action", "require-all", "role", "sequential"], }), ) def test_refuse_invalid_attribute_value(self): assert_raise_library_error( lambda: resource_set.prepare_set(mock.Mock(), { "ids": ["A", "B"], "options": {"role": "invalid"} }), (severities.ERROR, report_codes.INVALID_OPTION_VALUE, { 'option_name': 'role', 'allowed_values': ('Stopped', 'Started', 'Master', 'Slave'), 'option_value': 'invalid', }), ) class ExtractIdListTest(TestCase): def test_return_id_list_from_resource_set_list(self): self.assertEqual( [["A", "B"], ["C", "D"]], resource_set.extract_id_set_list([ {"ids": ["A", "B"], "options": {}}, {"ids": ["C", "D"], "options": {}}, ]) ) class CreateTest(TestCase): def test_resource_set_to_parent(self): constraint_element = etree.Element("constraint") resource_set.create( constraint_element, {"ids": ["A", "B"], "options": {"sequential": "true"}}, ) assert_xml_equal(etree.tostring(constraint_element).decode(), """ """) class GetResourceIdListTest(TestCase): def test_returns_id_list_from_element(self): element = etree.Element("resource_set") for id in ("A", "B"): etree.SubElement(element, "resource_ref").attrib["id"] = id self.assertEqual( ["A", "B"], resource_set.get_resource_id_set_list(element) ) class ExportTest(TestCase): def test_returns_element_in_dict_representation(self): element = etree.Element("resource_set") element.attrib.update({"role": "Master"}) for id in ("A", "B"): etree.SubElement(element, "resource_ref").attrib["id"] = id self.assertEqual( {'options': {'role': 'Master'}, 'ids': ['A', 'B']}, resource_set.export(element) ) pcs-0.9.155/pcs/lib/cib/tools.py000066400000000000000000000171741301012375000162640ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os import re import tempfile from lxml import etree from pcs import settings from pcs.common.tools import join_multilines from pcs.lib import reports from pcs.lib.errors import LibraryError from pcs.lib.pacemaker_values import validate_id def does_id_exist(tree, check_id): """ Checks to see if id exists in the xml dom passed tree cib etree node check_id id to check """ # ElementTree has getroot, Elemet has getroottree root = tree.getroot() if hasattr(tree, "getroot") else tree.getroottree() # do not search in /cib/status, it may contain references to previously # existing and deleted resources and thus preventing creating them again existing = root.xpath( ( '(/cib/*[name()!="status"]|/*[name()!="cib"])' + '//*[name()!="acl_target" and name()!="role" and @id="{0}"]' ).format(check_id) ) return len(existing) > 0 def validate_id_does_not_exist(tree, id): """ tree cib etree node """ if does_id_exist(tree, id): raise LibraryError(reports.id_already_exists(id)) def find_unique_id(tree, check_id): """ Returns check_id if it doesn't exist in the dom, otherwise it adds an integer to the end of the id and increments it until a unique id is found tree cib etree node check_id id to check """ counter = 1 temp_id = check_id while does_id_exist(tree, temp_id): temp_id = "{0}-{1}".format(check_id, counter) counter += 1 return temp_id def create_subelement_id(context_element, suffix): return find_unique_id( context_element, "{0}-{1}".format(context_element.get("id"), suffix) ) def check_new_id_applicable(tree, description, id): validate_id(id, description) validate_id_does_not_exist(tree, id) def _get_mandatory_section(tree, section_name): """ Return required element from tree, raise LibraryError if missing tree cib etree node """ section = tree.find(".//{0}".format(section_name)) if section is not None: return section raise LibraryError(reports.cib_missing_mandatory_section(section_name)) def get_configuration(tree): """ Return 'configuration' element from tree, raise LibraryError if missing tree cib etree node """ return _get_mandatory_section(tree, "configuration") def get_acls(tree): """ Return 'acls' element from tree, create a new one if missing tree cib etree node """ acls = tree.find(".//acls") if acls is None: acls = etree.SubElement(get_configuration(tree), "acls") return acls def get_alerts(tree): """ Return 'alerts' element from tree, create a new one if missing tree -- cib etree node """ return get_sub_element(get_configuration(tree), "alerts") def get_constraints(tree): """ Return 'constraint' element from tree tree cib etree node """ return _get_mandatory_section(tree, "configuration/constraints") def get_resources(tree): """ Return 'resources' element from tree tree cib etree node """ return _get_mandatory_section(tree, "configuration/resources") def find_parent(element, tag_names): candidate = element while True: if candidate is None or candidate.tag in tag_names: return candidate candidate = candidate.getparent() def export_attributes(element): return dict((key, value) for key, value in element.attrib.items()) def get_sub_element(element, sub_element_tag, new_id=None, new_index=None): """ Returns the FIRST sub-element sub_element_tag of element. It will create new element if such doesn't exist yet. Id of new element will be new_if if it's not None. new_index specify where will be new element added, if None it will be appended. element -- parent element sub_element_tag -- tag of wanted element new_id -- id of new element new_index -- index for new element """ sub_element = element.find("./{0}".format(sub_element_tag)) if sub_element is None: sub_element = etree.Element(sub_element_tag) if new_id: sub_element.set("id", new_id) if new_index is None: element.append(sub_element) else: element.insert(new_index, sub_element) return sub_element def get_pacemaker_version_by_which_cib_was_validated(cib): """ Return version of pacemaker which validated specified cib as tree. Version is returned as tuple of integers: (, , ). Raises LibraryError on any failure. cib -- cib etree """ version = cib.get("validate-with") if version is None: raise LibraryError(reports.cib_load_error_invalid_format()) regexp = re.compile( r"pacemaker-(?P\d+)\.(?P\d+)(\.(?P\d+))?" ) match = regexp.match(version) if not match: raise LibraryError(reports.cib_load_error_invalid_format()) return ( int(match.group("major")), int(match.group("minor")), int(match.group("rev") or 0) ) def upgrade_cib(cib, runner): """ Upgrade CIB to the latest schema of installed pacemaker. Returns upgraded CIB as string. Raises LibraryError on any failure. cib -- cib etree runner -- CommandRunner """ temp_file = None try: temp_file = tempfile.NamedTemporaryFile("w+", suffix=".pcs") temp_file.write(etree.tostring(cib).decode()) temp_file.flush() stdout, stderr, retval = runner.run( [ os.path.join(settings.pacemaker_binaries, "cibadmin"), "--upgrade", "--force" ], env_extend={"CIB_file": temp_file.name} ) if retval != 0: temp_file.close() raise LibraryError( reports.cib_upgrade_failed(join_multilines([stderr, stdout])) ) temp_file.seek(0) return etree.fromstring(temp_file.read()) except (EnvironmentError, etree.XMLSyntaxError, etree.DocumentInvalid) as e: raise LibraryError(reports.cib_upgrade_failed(str(e))) finally: if temp_file: temp_file.close() def ensure_cib_version(runner, cib, version): """ This method ensures that specified cib is verified by pacemaker with version 'version' or newer. If cib doesn't correspond to this version, method will try to upgrade cib. Returns cib which was verified by pacemaker version 'version' or later. Raises LibraryError on any failure. runner -- CommandRunner cib -- cib tree version -- tuple of integers (, , ) """ current_version = get_pacemaker_version_by_which_cib_was_validated( cib ) if current_version >= version: return None upgraded_cib = upgrade_cib(cib, runner) current_version = get_pacemaker_version_by_which_cib_was_validated( upgraded_cib ) if current_version >= version: return upgraded_cib raise LibraryError(reports.unable_to_upgrade_cib_to_required_version( current_version, version )) def etree_element_attibutes_to_dict(etree_el, required_key_list): """ Returns all attributes of etree_el from required_key_list in dictionary, where keys are attributes and values are values of attributes or None if it's not present. etree_el -- etree element from which attributes should be extracted required_key_list -- list of strings, attributes names which should be extracted """ return dict([(key, etree_el.get(key)) for key in required_key_list]) pcs-0.9.155/pcs/lib/cluster_conf_facade.py000066400000000000000000000031341301012375000203270ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from lxml import etree from pcs.lib import reports from pcs.lib.errors import LibraryError from pcs.lib.node import NodeAddresses, NodeAddressesList class ClusterConfFacade(object): """ Provides high level access to a corosync.conf file """ @classmethod def from_string(cls, config_string): """ Parse cluster.conf config and create a facade around it config_string -- cluster.conf file content as string """ try: return cls(etree.fromstring(config_string)) except (etree.XMLSyntaxError, etree.DocumentInvalid) as e: raise LibraryError(reports.cluster_conf_invalid_format(str(e))) def __init__(self, parsed_config): """ Create a facade around a parsed cluster.conf config file parsed_config parsed cluster.conf config """ self._config = parsed_config @property def config(self): return self._config def get_cluster_name(self): return self.config.get("name", "") def get_nodes(self): """ Get all defined nodes """ result = NodeAddressesList() for node in self.config.findall("./clusternodes/clusternode"): altname = node.find("altname") result.append(NodeAddresses( ring0=node.get("name"), ring1=altname.get("name") if altname is not None else None, name=None, id=node.get("nodeid") )) return result pcs-0.9.155/pcs/lib/commands/000077500000000000000000000000001301012375000156045ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/commands/__init__.py000066400000000000000000000000001301012375000177030ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/commands/acl.py000066400000000000000000000244071301012375000167240ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.lib import reports from pcs.lib.cib import acl from pcs.lib.errors import LibraryError REQUIRED_CIB_VERSION = (2, 0, 0) def create_role(lib_env, role_id, permission_info_list, description): """ Create new acl role. Raises LibraryError on any failure. lib_env -- LibraryEnvirnoment role_id -- id of new role which should be created permission_info_list -- list of permissons, items of list should be tuples: (, , ) description -- text description for role """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) if permission_info_list: acl.validate_permissions(cib, permission_info_list) role_el = acl.create_role(cib, role_id, description) if permission_info_list: acl.add_permissions_to_role(role_el, permission_info_list) lib_env.push_cib(cib) def remove_role(lib_env, role_id, autodelete_users_groups=False): """ Remove role with specified id from CIB. Raises LibraryError on any failure. lib_env -- LibraryEnvironment role_id -- id of role which should be deleted autodelete_users_groups -- if True targets and groups which are empty after removal will be removed """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) try: acl.remove_role(cib, role_id, autodelete_users_groups) except acl.AclRoleNotFound as e: raise LibraryError(acl.acl_error_to_report_item(e)) lib_env.push_cib(cib) def assign_role_not_specific(lib_env, role_id, target_or_group_id): """ Assign role wth id role_id to target or group with id target_or_group_id. Target element has bigger pririty so if there are target and group with same id only target element will be affected by this function. Raises LibraryError on any failure. lib_env -- LibraryEnviroment role_id -- id of role which should be assigne to target/group target_or_group_id -- id of target/group element """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) try: acl.assign_role( _get_target_or_group(cib, target_or_group_id), acl.find_role(cib, role_id) ) except acl.AclError as e: raise LibraryError(acl.acl_error_to_report_item(e)) lib_env.push_cib(cib) def _get_target_or_group(cib, target_or_group_id): """ Returns acl_target or acl_group element with id target_or_group_id. Target element has bigger pririty so if there are target and group with same id only target element will be affected by this function. Raises LibraryError if there is no target or group element with specified id. cib -- cib etree node target_or_group_id -- id of target/group element which should be returned """ try: return acl.find_target(cib, target_or_group_id) except acl.AclTargetNotFound: try: return acl.find_group(cib, target_or_group_id) except acl.AclGroupNotFound: raise LibraryError( reports.id_not_found(target_or_group_id, "user/group") ) def assign_role_to_target(lib_env, role_id, target_id): """ Assign role with id role_id to target with id target_id. Raises LibraryError on any failure. lib_env -- LibraryEnvironment role_id -- id of acl_role element which should be assigned to target target_id -- id of acl_target element to which role should be assigned """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) try: acl.assign_role( acl.find_target(cib, target_id), acl.find_role(cib, role_id) ) except acl.AclError as e: raise LibraryError(acl.acl_error_to_report_item(e)) lib_env.push_cib(cib) def assign_role_to_group(lib_env, role_id, group_id): """ Assign role with id role_id to group with id group_id. Raises LibraryError on any failure. lib_env -- LibraryEnvironment role_id -- id of acl_role element which should be assigned to group group_id -- id of acl_group element to which role should be assigned """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) try: acl.assign_role( acl.find_group(cib, group_id), acl.find_role(cib, role_id) ) except acl.AclError as e: raise LibraryError(acl.acl_error_to_report_item(e)) lib_env.push_cib(cib) def unassign_role_not_specific( lib_env, role_id, target_or_group_id, autodelete_target_group=False ): """ Unassign role with role_id from target/group with id target_or_group_id. Target element has bigger pririty so if there are target and group with same id only target element will be affected by this function. Raises LibraryError on any failure. lib_env -- LibraryEnvironment role_id -- id of role which should be unassigned from target/group target_or_group_id -- id of acl_target/acl_group element autodelete_target_group -- if True remove target/group element if has no more role assigned """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) acl.unassign_role( _get_target_or_group(cib, target_or_group_id), role_id, autodelete_target_group ) lib_env.push_cib(cib) def unassign_role_from_target( lib_env, role_id, target_id, autodelete_target=False ): """ Unassign role with role_id from group with id target_id. Raises LibraryError on any failure. lib_env -- LibraryEnvironment role_id -- id of role which should be unassigned from target target_id -- id of acl_target element autodelete_target -- if True remove target element if has no more role assigned """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) try: acl.unassign_role( acl.find_target(cib, target_id), role_id, autodelete_target ) except acl.AclError as e: raise LibraryError(acl.acl_error_to_report_item(e)) lib_env.push_cib(cib) def unassign_role_from_group( lib_env, role_id, group_id, autodelete_group=False ): """ Unassign role with role_id from group with id group_id. Raises LibraryError on any failure. lib_env -- LibraryEnvironment role_id -- id of role which should be unassigned from group group_id -- id of acl_group element autodelete_target -- if True remove group element if has no more role assigned """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) try: acl.unassign_role( acl.find_group(cib, group_id), role_id, autodelete_group ) except acl.AclError as e: raise LibraryError(acl.acl_error_to_report_item(e)) lib_env.push_cib(cib) def _assign_roles_to_element(cib, element, role_id_list): """ Assign roles from role_id_list to element. Raises LibraryError on any failure. cib -- cib etree node element -- element to which specified roles should be assigned role_id_list -- list of role id """ report_list = [] for role_id in role_id_list: try: acl.assign_role(element, acl.find_role(cib, role_id)) except acl.AclError as e: report_list.append(acl.acl_error_to_report_item(e)) if report_list: raise LibraryError(*report_list) def create_target(lib_env, target_id, role_list): """ Create new target with id target_id and assign roles role_list to it. Raises LibraryError on any failure. lib_env -- LibraryEnvironment target_id -- id of new target role_list -- list of roles to assign to new target """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) _assign_roles_to_element(cib, acl.create_target(cib, target_id), role_list) lib_env.push_cib(cib) def create_group(lib_env, group_id, role_list): """ Create new group with id group_id and assign roles role_list to it. Raises LibraryError on any failure. lib_env -- LibraryEnvironment group_id -- id of new group role_list -- list of roles to assign to new group """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) _assign_roles_to_element(cib, acl.create_group(cib, group_id), role_list) lib_env.push_cib(cib) def remove_target(lib_env, target_id): """ Remove acl_target element with id target_id. Raises LibraryError on any failure. lib_env -- LibraryEnvironment target_id -- id of taget which should be removed """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) acl.remove_target(cib, target_id) lib_env.push_cib(cib) def remove_group(lib_env, group_id): """ Remove acl_group element with id group_id. Raises LibraryError on any failure. lib_env -- LibraryEnvironment group_id -- id of group which should be removed """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) acl.remove_group(cib, group_id) lib_env.push_cib(cib) def add_permission(lib_env, role_id, permission_info_list): """ Add permissions do role with id role_id. If role doesn't exist it will be created. Raises LibraryError on any failure. lib_env -- LibraryEnvirnoment role_id -- id of role permission_info_list -- list of permissons, items of list should be tuples: (, , ) """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) acl.validate_permissions(cib, permission_info_list) acl.add_permissions_to_role( acl.provide_role(cib, role_id), permission_info_list ) lib_env.push_cib(cib) def remove_permission(lib_env, permission_id): """ Remove permission with id permission_id. Raises LibraryError on any failure. lib_env -- LibraryEnvironment permission_id -- id of permission element which should be removed """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) acl.remove_permission(cib, permission_id) lib_env.push_cib(cib) def get_config(lib_env): """ Returns ACL configuration in disctionary. Fromat of output: { "target_list": , "group_list": , "role_list": , } lib_env -- LibraryEnvironment """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) return { "target_list": acl.get_target_list(cib), "group_list": acl.get_group_list(cib), "role_list": acl.get_role_list(cib), } pcs-0.9.155/pcs/lib/commands/alert.py000066400000000000000000000136011301012375000172660ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.lib import reports from pcs.lib.cib import alert from pcs.lib.errors import LibraryError REQUIRED_CIB_VERSION = (2, 5, 0) def create_alert( lib_env, alert_id, path, instance_attribute_dict, meta_attribute_dict, description=None ): """ Create new alert. Raises LibraryError if path is not specified, or any other failure. lib_env -- LibraryEnvironment alert_id -- id of alert to be created, if None it will be generated path -- path to script for alert instance_attribute_dict -- dictionary of instance attributes meta_attribute_dict -- dictionary of meta attributes description -- alert description description """ if not path: raise LibraryError(reports.required_option_is_missing("path")) cib = lib_env.get_cib(REQUIRED_CIB_VERSION) alert_el = alert.create_alert(cib, alert_id, path, description) alert.update_instance_attributes(alert_el, instance_attribute_dict) alert.update_meta_attributes(alert_el, meta_attribute_dict) lib_env.push_cib(cib) def update_alert( lib_env, alert_id, path, instance_attribute_dict, meta_attribute_dict, description=None ): """ Update existing alert with specified id. lib_env -- LibraryEnvironment alert_id -- id of alert to be updated path -- new path, if None old value will stay unchanged instance_attribute_dict -- dictionary of instance attributes to update meta_attribute_dict -- dictionary of meta attributes to update description -- new description, if empty string, old description will be deleted, if None old value will stay unchanged """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) alert_el = alert.update_alert(cib, alert_id, path, description) alert.update_instance_attributes(alert_el, instance_attribute_dict) alert.update_meta_attributes(alert_el, meta_attribute_dict) lib_env.push_cib(cib) def remove_alert(lib_env, alert_id_list): """ Remove alerts with specified ids. lib_env -- LibraryEnvironment alert_id_list -- list of alerts ids which should be removed """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) report_list = [] for alert_id in alert_id_list: try: alert.remove_alert(cib, alert_id) except LibraryError as e: report_list += e.args lib_env.report_processor.process_list(report_list) lib_env.push_cib(cib) def add_recipient( lib_env, alert_id, recipient_value, instance_attribute_dict, meta_attribute_dict, recipient_id=None, description=None, allow_same_value=False ): """ Add new recipient to alert witch id alert_id. lib_env -- LibraryEnvironment alert_id -- id of alert to which new recipient should be added recipient_value -- value of new recipient instance_attribute_dict -- dictionary of instance attributes to update meta_attribute_dict -- dictionary of meta attributes to update recipient_id -- id of new recipient, if None it will be generated description -- recipient description allow_same_value -- if True unique recipient value is not required """ if not recipient_value: raise LibraryError( reports.required_option_is_missing("value") ) cib = lib_env.get_cib(REQUIRED_CIB_VERSION) recipient = alert.add_recipient( lib_env.report_processor, cib, alert_id, recipient_value, recipient_id=recipient_id, description=description, allow_same_value=allow_same_value ) alert.update_instance_attributes(recipient, instance_attribute_dict) alert.update_meta_attributes(recipient, meta_attribute_dict) lib_env.push_cib(cib) def update_recipient( lib_env, recipient_id, instance_attribute_dict, meta_attribute_dict, recipient_value=None, description=None, allow_same_value=False ): """ Update existing recipient. lib_env -- LibraryEnvironment recipient_id -- id of recipient to be updated instance_attribute_dict -- dictionary of instance attributes to update meta_attribute_dict -- dictionary of meta attributes to update recipient_value -- new recipient value, if None old value will stay unchanged description -- new description, if empty string, old description will be deleted, if None old value will stay unchanged allow_same_value -- if True unique recipient value is not required """ if not recipient_value and recipient_value is not None: raise LibraryError( reports.cib_alert_recipient_invalid_value(recipient_value) ) cib = lib_env.get_cib(REQUIRED_CIB_VERSION) recipient = alert.update_recipient( lib_env.report_processor, cib, recipient_id, recipient_value=recipient_value, description=description, allow_same_value=allow_same_value ) alert.update_instance_attributes(recipient, instance_attribute_dict) alert.update_meta_attributes(recipient, meta_attribute_dict) lib_env.push_cib(cib) def remove_recipient(lib_env, recipient_id_list): """ Remove specified recipients. lib_env -- LibraryEnvironment recipient_id_list -- list of recipients ids to be removed """ cib = lib_env.get_cib(REQUIRED_CIB_VERSION) report_list = [] for recipient_id in recipient_id_list: try: alert.remove_recipient(cib, recipient_id) except LibraryError as e: report_list += e.args lib_env.report_processor.process_list(report_list) lib_env.push_cib(cib) def get_all_alerts(lib_env): """ Returns list of all alerts. See docs of pcs.lib.cib.alert.get_all_alerts for description of data format. lib_env -- LibraryEnvironment """ return alert.get_all_alerts(lib_env.get_cib()) pcs-0.9.155/pcs/lib/commands/booth.py000066400000000000000000000276441301012375000173060ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import base64 import os.path from functools import partial from pcs import settings from pcs.common.tools import join_multilines from pcs.lib import external, reports from pcs.lib.booth import ( config_exchange, config_files, config_structure, reports as booth_reports, resource, status, sync, ) from pcs.lib.booth.config_parser import parse, build from pcs.lib.booth.env import get_config_file_name from pcs.lib.cib.tools import get_resources from pcs.lib.errors import LibraryError, ReportItemSeverity from pcs.lib.node import NodeAddresses def config_setup(env, booth_configuration, overwrite_existing=False): """ create boot configuration list site_list contains site adresses of multisite list arbitrator_list contains arbitrator adresses of multisite """ config_content = config_exchange.from_exchange_format(booth_configuration) config_structure.validate_peers( *config_structure.take_peers(config_content) ) env.booth.create_key(config_files.generate_key(), overwrite_existing) config_content = config_structure.set_authfile( config_content, env.booth.key_path ) env.booth.create_config(build(config_content), overwrite_existing) def config_destroy(env, ignore_config_load_problems=False): env.booth.command_expect_live_env() env.command_expect_live_corosync_env() name = env.booth.name config_is_used = partial(booth_reports.booth_config_is_used, name) report_list = [] if(env.is_node_in_cluster() and resource.find_for_config( get_resources(env.get_cib()), get_config_file_name(name), )): report_list.append(config_is_used("in cluster resource")) #Only systemd is currently supported. Initd does not supports multiple #instances (here specified by name) if external.is_systemctl(): if external.is_service_running(env.cmd_runner(), "booth", name): report_list.append(config_is_used("(running in systemd)")) if external.is_service_enabled(env.cmd_runner(), "booth", name): report_list.append(config_is_used("(enabled in systemd)")) if report_list: raise LibraryError(*report_list) authfile_path = None try: authfile_path = config_structure.get_authfile( parse(env.booth.get_config_content()) ) except LibraryError: if not ignore_config_load_problems: raise LibraryError(booth_reports.booth_cannot_identify_keyfile()) #if content not received, not valid,... still remove config needed env.report_processor.process( booth_reports.booth_cannot_identify_keyfile( severity=ReportItemSeverity.WARNING ) ) if( authfile_path and os.path.dirname(authfile_path) == settings.booth_config_dir ): env.booth.set_key_path(authfile_path) env.booth.remove_key() env.booth.remove_config() def config_text(env, name, node_name=None): """ get configuration in raw format string name -- name of booth instance whose config should be returned string node_name -- get the config from specified node or local host if None """ if node_name is None: # TODO add name support return env.booth.get_config_content() remote_data = sync.pull_config_from_node( env.node_communicator(), NodeAddresses(node_name), name ) try: return remote_data["config"]["data"] except KeyError: raise LibraryError(reports.invalid_response_format(node_name)) def config_ticket_add(env, ticket_name, options, allow_unknown_options): """ add ticket to booth configuration dict options contains options for ticket bool allow_unknown_options decide if can be used options not listed in ticket options nor global options """ booth_configuration = config_structure.add_ticket( env.report_processor, parse(env.booth.get_config_content()), ticket_name, options, allow_unknown_options, ) env.booth.push_config(build(booth_configuration)) def config_ticket_remove(env, ticket_name): """ remove ticket from booth configuration """ booth_configuration = config_structure.remove_ticket( parse(env.booth.get_config_content()), ticket_name ) env.booth.push_config(build(booth_configuration)) def create_in_cluster(env, name, ip, resource_create, resource_remove): #TODO resource_create is provisional hack until resources are not moved to #lib resources_section = get_resources(env.get_cib()) booth_config_file_path = get_config_file_name(name) if resource.find_for_config(resources_section, booth_config_file_path): raise LibraryError(booth_reports.booth_already_in_cib(name)) resource.get_creator(resource_create, resource_remove)( ip, booth_config_file_path, create_id = partial( resource.create_resource_id, resources_section, name ) ) def remove_from_cluster(env, name, resource_remove, allow_remove_multiple): #TODO resource_remove is provisional hack until resources are not moved to #lib resource.get_remover(resource_remove)( _find_resource_elements_for_operation(env, name, allow_remove_multiple) ) def restart(env, name, resource_restart, allow_multiple): #TODO resource_restart is provisional hack until resources are not moved to #lib for booth_element in _find_resource_elements_for_operation( env, name, allow_multiple ): resource_restart([booth_element.attrib["id"]]) def ticket_operation(operation, env, name, ticket, site_ip): if not site_ip: site_ip_list = resource.find_bound_ip( get_resources(env.get_cib()), get_config_file_name(name) ) if len(site_ip_list) != 1: raise LibraryError( booth_reports.booth_cannot_determine_local_site_ip() ) site_ip = site_ip_list[0] stdout, stderr, return_code = env.cmd_runner().run([ settings.booth_binary, operation, "-s", site_ip, ticket ]) if return_code != 0: raise LibraryError( booth_reports.booth_ticket_operation_failed( operation, join_multilines([stderr, stdout]), site_ip, ticket ) ) ticket_grant = partial(ticket_operation, "grant") ticket_revoke = partial(ticket_operation, "revoke") def config_sync(env, name, skip_offline_nodes=False): """ Send specified local booth configuration to all nodes in cluster. env -- LibraryEnvironment name -- booth instance name skip_offline_nodes -- if True offline nodes will be skipped """ config = env.booth.get_config_content() authfile_path = config_structure.get_authfile(parse(config)) authfile_content = config_files.read_authfile( env.report_processor, authfile_path ) sync.send_config_to_all_nodes( env.node_communicator(), env.report_processor, env.get_corosync_conf().get_nodes(), name, config, authfile=authfile_path, authfile_data=authfile_content, skip_offline=skip_offline_nodes ) def enable_booth(env, name=None): """ Enable specified instance of booth service. Currently it is supported only systemd systems. env -- LibraryEnvironment name -- string, name of booth instance """ external.ensure_is_systemd() try: external.enable_service(env.cmd_runner(), "booth", name) except external.EnableServiceError as e: raise LibraryError(reports.service_enable_error( "booth", e.message, instance=name )) env.report_processor.process(reports.service_enable_success( "booth", instance=name )) def disable_booth(env, name=None): """ Disable specified instance of booth service. Currently it is supported only systemd systems. env -- LibraryEnvironment name -- string, name of booth instance """ external.ensure_is_systemd() try: external.disable_service(env.cmd_runner(), "booth", name) except external.DisableServiceError as e: raise LibraryError(reports.service_disable_error( "booth", e.message, instance=name )) env.report_processor.process(reports.service_disable_success( "booth", instance=name )) def start_booth(env, name=None): """ Start specified instance of booth service. Currently it is supported only systemd systems. On non systems it can be run like this: BOOTH_CONF_FILE= /etc/initd/booth-arbitrator env -- LibraryEnvironment name -- string, name of booth instance """ external.ensure_is_systemd() try: external.start_service(env.cmd_runner(), "booth", name) except external.StartServiceError as e: raise LibraryError(reports.service_start_error( "booth", e.message, instance=name )) env.report_processor.process(reports.service_start_success( "booth", instance=name )) def stop_booth(env, name=None): """ Stop specified instance of booth service. Currently it is supported only systemd systems. env -- LibraryEnvironment name -- string, name of booth instance """ external.ensure_is_systemd() try: external.stop_service(env.cmd_runner(), "booth", name) except external.StopServiceError as e: raise LibraryError(reports.service_stop_error( "booth", e.message, instance=name )) env.report_processor.process(reports.service_stop_success( "booth", instance=name )) def pull_config(env, node_name, name): """ Get config from specified node and save it on local system. It will rewrite existing files. env -- LibraryEnvironment node_name -- string, name of node from which config should be fetched name -- string, name of booth instance of which config should be fetched """ env.report_processor.process( booth_reports.booth_fetching_config_from_node_started(node_name, name) ) output = sync.pull_config_from_node( env.node_communicator(), NodeAddresses(node_name), name ) try: env.booth.create_config(output["config"]["data"], True) if ( output["authfile"]["name"] is not None and output["authfile"]["data"] ): env.booth.set_key_path(os.path.join( settings.booth_config_dir, output["authfile"]["name"] )) env.booth.create_key( base64.b64decode( output["authfile"]["data"].encode("utf-8") ), True ) env.report_processor.process( booth_reports.booth_config_accepted_by_node(name_list=[name]) ) except KeyError: raise LibraryError(reports.invalid_response_format(node_name)) def get_status(env, name=None): return { "status": status.get_daemon_status(env.cmd_runner(), name), "ticket": status.get_tickets_status(env.cmd_runner(), name), "peers": status.get_peers_status(env.cmd_runner(), name), } def _find_resource_elements_for_operation(env, name, allow_multiple): booth_element_list = resource.find_for_config( get_resources(env.get_cib()), get_config_file_name(name), ) if not booth_element_list: raise LibraryError(booth_reports.booth_not_exists_in_cib(name)) if len(booth_element_list) > 1: if not allow_multiple: raise LibraryError(booth_reports.booth_multiple_times_in_cib(name)) env.report_processor.process( booth_reports.booth_multiple_times_in_cib( name, severity=ReportItemSeverity.WARNING, ) ) return booth_element_list pcs-0.9.155/pcs/lib/commands/constraint/000077500000000000000000000000001301012375000177705ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/commands/constraint/__init__.py000066400000000000000000000000001301012375000220670ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/commands/constraint/colocation.py000066400000000000000000000011141301012375000224710ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from functools import partial from pcs.lib.cib.constraint import colocation import pcs.lib.commands.constraint.common #configure common constraint command show = partial( pcs.lib.commands.constraint.common.show, colocation.TAG_NAME, lambda element: element.attrib.has_key('rsc') ) #configure common constraint command create_with_set = partial( pcs.lib.commands.constraint.common.create_with_set, colocation.TAG_NAME, colocation.prepare_options_with_set ) pcs-0.9.155/pcs/lib/commands/constraint/common.py000066400000000000000000000056541301012375000216440ustar00rootroot00000000000000""" Common functions used from specific constraint commands. Functions of this module are not intended to be used for direct call from client. """ from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from functools import partial from pcs.lib.cib.constraint import constraint, resource_set from pcs.lib.cib.tools import get_constraints def create_with_set( tag_name, prepare_options, env, resource_set_list, constraint_options, can_repair_to_clone=False, resource_in_clone_alowed=False, duplication_alowed=False, duplicate_check=None, ): """ string tag_name is constraint tag name callable prepare_options takes cib(Element), options(dict), resource_set_list and return corrected options or if options not usable raises error env is library environment list resource_set_list is description of resource set, for example: {"ids": ["A", "B"], "options": {"sequential": "true"}}, dict constraint_options is base for building attributes of constraint tag bool resource_in_clone_alowed flag for allowing to reference id which is in tag clone or master bool duplication_alowed flag for allowing create duplicate element callable duplicate_check takes two elements and decide if they are duplicates """ cib = env.get_cib() find_valid_resource_id = partial( constraint.find_valid_resource_id, env.report_processor, cib, can_repair_to_clone, resource_in_clone_alowed ) constraint_section = get_constraints(cib) constraint_element = constraint.create_with_set( constraint_section, tag_name, options=prepare_options(cib, constraint_options, resource_set_list), resource_set_list=[ resource_set.prepare_set(find_valid_resource_id, resource_set_item) for resource_set_item in resource_set_list ] ) if not duplicate_check: duplicate_check = constraint.have_duplicate_resource_sets constraint.check_is_without_duplication( env.report_processor, constraint_section, constraint_element, are_duplicate=duplicate_check, export_element=constraint.export_with_set, duplication_alowed=duplication_alowed, ) env.push_cib(cib) def show(tag_name, is_plain, env): """ string tag_name is constraint tag name callable is_plain takes constraint element and returns if is plain (i.e. without resource set) env is library environment """ constraints_info = {"plain": [], "with_resource_sets": []} for element in get_constraints(env.get_cib()).findall(".//"+tag_name): if is_plain(element): constraints_info["plain"].append(constraint.export_plain(element)) else: constraints_info["with_resource_sets"].append( constraint.export_with_set(element) ) return constraints_info pcs-0.9.155/pcs/lib/commands/constraint/order.py000066400000000000000000000010711301012375000214540ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from functools import partial from pcs.lib.cib.constraint import order import pcs.lib.commands.constraint.common #configure common constraint command show = partial( pcs.lib.commands.constraint.common.show, order.TAG_NAME, lambda element: element.attrib.has_key('first') ) #configure common constraint command create_with_set = partial( pcs.lib.commands.constraint.common.create_with_set, order.TAG_NAME, order.prepare_options_with_set ) pcs-0.9.155/pcs/lib/commands/constraint/ticket.py000066400000000000000000000051611301012375000216300ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from functools import partial from pcs.lib.cib.constraint import constraint, ticket from pcs.lib.cib.tools import get_constraints import pcs.lib.commands.constraint.common #configure common constraint command show = partial( pcs.lib.commands.constraint.common.show, ticket.TAG_NAME, lambda element: element.attrib.has_key('rsc') ) #configure common constraint command create_with_set = partial( pcs.lib.commands.constraint.common.create_with_set, ticket.TAG_NAME, ticket.prepare_options_with_set, duplicate_check=ticket.are_duplicate_with_resource_set, ) def create( env, ticket_key, resource_id, options, autocorrection_allowed=False, resource_in_clone_alowed=False, duplication_alowed=False, ): """ create ticket constraint string ticket_key ticket for constraining resource dict options desired constraint attributes bool resource_in_clone_alowed flag for allowing to reference id which is in tag clone or master bool duplication_alowed flag for allowing create duplicate element callable duplicate_check takes two elements and decide if they are duplicates """ cib = env.get_cib() options = ticket.prepare_options_plain( cib, options, ticket_key, constraint.find_valid_resource_id( env.report_processor, cib, autocorrection_allowed, resource_in_clone_alowed, resource_id ), ) constraint_section = get_constraints(cib) constraint_element = ticket.create_plain(constraint_section, options) constraint.check_is_without_duplication( env.report_processor, constraint_section, constraint_element, are_duplicate=ticket.are_duplicate_plain, export_element=constraint.export_plain, duplication_alowed=duplication_alowed, ) env.push_cib(cib) def remove(env, ticket_key, resource_id): """ remove all ticket constraint from resource If resource is in resource set with another resources then only resource ref is removed. If resource is alone in resource set whole constraint is removed. """ cib = env.get_cib() constraint_section = get_constraints(cib) any_plain_removed = ticket.remove_plain( constraint_section, ticket_key, resource_id ) any_with_resource_set_removed = ticket.remove_with_resource_set( constraint_section, ticket_key, resource_id ) env.push_cib(cib) return any_plain_removed or any_with_resource_set_removed pcs-0.9.155/pcs/lib/commands/qdevice.py000066400000000000000000000205261301012375000176030ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import base64 import binascii from pcs.common import report_codes from pcs.lib import external, reports from pcs.lib.corosync import qdevice_net from pcs.lib.errors import LibraryError, ReportItemSeverity def qdevice_setup(lib_env, model, enable, start): """ Initialize qdevice on local host with specified model string model qdevice model to initialize bool enable make qdevice service start on boot bool start start qdevice now """ _ensure_not_cman(lib_env) _check_model(model) qdevice_net.qdevice_setup(lib_env.cmd_runner()) lib_env.report_processor.process( reports.qdevice_initialization_success(model) ) if enable: _service_enable(lib_env, qdevice_net.qdevice_enable) if start: _service_start(lib_env, qdevice_net.qdevice_start) def qdevice_destroy(lib_env, model, proceed_if_used=False): """ Stop and disable qdevice on local host and remove its configuration string model qdevice model to destroy bool procced_if_used destroy qdevice even if it is used by clusters """ _ensure_not_cman(lib_env) _check_model(model) _check_qdevice_not_used( lib_env.report_processor, lib_env.cmd_runner(), model, proceed_if_used ) _service_stop(lib_env, qdevice_net.qdevice_stop) _service_disable(lib_env, qdevice_net.qdevice_disable) qdevice_net.qdevice_destroy() lib_env.report_processor.process(reports.qdevice_destroy_success(model)) def qdevice_status_text(lib_env, model, verbose=False, cluster=None): """ Get runtime status of a quorum device in plain text string model qdevice model to query bool verbose get more detailed output string cluster show information only about specified cluster """ _ensure_not_cman(lib_env) _check_model(model) runner = lib_env.cmd_runner() try: return ( qdevice_net.qdevice_status_generic_text(runner, verbose) + qdevice_net.qdevice_status_cluster_text(runner, cluster, verbose) ) except qdevice_net.QnetdNotRunningException: raise LibraryError( reports.qdevice_not_running(model) ) def qdevice_enable(lib_env, model): """ make qdevice start automatically on boot on local host """ _ensure_not_cman(lib_env) _check_model(model) _service_enable(lib_env, qdevice_net.qdevice_enable) def qdevice_disable(lib_env, model): """ make qdevice not start automatically on boot on local host """ _ensure_not_cman(lib_env) _check_model(model) _service_disable(lib_env, qdevice_net.qdevice_disable) def qdevice_start(lib_env, model): """ start qdevice now on local host """ _ensure_not_cman(lib_env) _check_model(model) _service_start(lib_env, qdevice_net.qdevice_start) def qdevice_stop(lib_env, model, proceed_if_used=False): """ stop qdevice now on local host string model qdevice model to destroy bool procced_if_used stop qdevice even if it is used by clusters """ _ensure_not_cman(lib_env) _check_model(model) _check_qdevice_not_used( lib_env.report_processor, lib_env.cmd_runner(), model, proceed_if_used ) _service_stop(lib_env, qdevice_net.qdevice_stop) def qdevice_kill(lib_env, model): """ kill qdevice now on local host """ _ensure_not_cman(lib_env) _check_model(model) _service_kill(lib_env, qdevice_net.qdevice_kill) def qdevice_net_sign_certificate_request( lib_env, certificate_request, cluster_name ): """ Sign node certificate request by qnetd CA string certificate_request base64 encoded certificate request string cluster_name name of the cluster to which qdevice is being added """ _ensure_not_cman(lib_env) try: certificate_request_data = base64.b64decode(certificate_request) except (TypeError, binascii.Error): raise LibraryError(reports.invalid_option_value( "qnetd certificate request", certificate_request, ["base64 encoded certificate"] )) return base64.b64encode( qdevice_net.qdevice_sign_certificate_request( lib_env.cmd_runner(), certificate_request_data, cluster_name ) ) def client_net_setup(lib_env, ca_certificate): """ Intialize qdevice net client on local host ca_certificate base64 encoded qnetd CA certificate """ _ensure_not_cman(lib_env) try: ca_certificate_data = base64.b64decode(ca_certificate) except (TypeError, binascii.Error): raise LibraryError(reports.invalid_option_value( "qnetd CA certificate", ca_certificate, ["base64 encoded certificate"] )) qdevice_net.client_setup(lib_env.cmd_runner(), ca_certificate_data) def client_net_import_certificate(lib_env, certificate): """ Import qnetd client certificate to local node certificate storage certificate base64 encoded qnetd client certificate """ _ensure_not_cman(lib_env) try: certificate_data = base64.b64decode(certificate) except (TypeError, binascii.Error): raise LibraryError(reports.invalid_option_value( "qnetd client certificate", certificate, ["base64 encoded certificate"] )) qdevice_net.client_import_certificate_and_key( lib_env.cmd_runner(), certificate_data ) def client_net_destroy(lib_env): """ delete qdevice client config files on local host """ _ensure_not_cman(lib_env) qdevice_net.client_destroy() def _ensure_not_cman(lib_env): if lib_env.is_cman_cluster: raise LibraryError(reports.cman_unsupported_command()) def _check_model(model): if model != "net": raise LibraryError( reports.invalid_option_value("model", model, ["net"]) ) def _check_qdevice_not_used(reporter, runner, model, force=False): _check_model(model) connected_clusters = [] if model == "net": try: status = qdevice_net.qdevice_status_cluster_text(runner) connected_clusters = qdevice_net.qdevice_connected_clusters(status) except qdevice_net.QnetdNotRunningException: pass if connected_clusters: reporter.process(reports.qdevice_used_by_clusters( connected_clusters, ReportItemSeverity.WARNING if force else ReportItemSeverity.ERROR, None if force else report_codes.FORCE_QDEVICE_USED )) def _service_start(lib_env, func): lib_env.report_processor.process( reports.service_start_started("quorum device") ) try: func(lib_env.cmd_runner()) except external.StartServiceError as e: raise LibraryError( reports.service_start_error(e.service, e.message) ) lib_env.report_processor.process( reports.service_start_success("quorum device") ) def _service_stop(lib_env, func): lib_env.report_processor.process( reports.service_stop_started("quorum device") ) try: func(lib_env.cmd_runner()) except external.StopServiceError as e: raise LibraryError( reports.service_stop_error(e.service, e.message) ) lib_env.report_processor.process( reports.service_stop_success("quorum device") ) def _service_kill(lib_env, func): try: func(lib_env.cmd_runner()) except external.KillServicesError as e: raise LibraryError( reports.service_kill_error(e.service, e.message) ) lib_env.report_processor.process( reports.service_kill_success(["quorum device"]) ) def _service_enable(lib_env, func): try: func(lib_env.cmd_runner()) except external.EnableServiceError as e: raise LibraryError( reports.service_enable_error(e.service, e.message) ) lib_env.report_processor.process( reports.service_enable_success("quorum device") ) def _service_disable(lib_env, func): try: func(lib_env.cmd_runner()) except external.DisableServiceError as e: raise LibraryError( reports.service_disable_error(e.service, e.message) ) lib_env.report_processor.process( reports.service_disable_success("quorum device") ) pcs-0.9.155/pcs/lib/commands/quorum.py000066400000000000000000000311541301012375000175120ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.common import report_codes from pcs.lib import reports, sbd from pcs.lib.errors import LibraryError, ReportItemSeverity from pcs.lib.corosync import ( live as corosync_live, qdevice_net, qdevice_client ) from pcs.lib.external import ( NodeCommunicationException, node_communicator_exception_to_report_item, parallel_nodes_communication_helper, ) def get_config(lib_env): """ Extract and return quorum configuration from corosync.conf lib_env LibraryEnvironment """ __ensure_not_cman(lib_env) cfg = lib_env.get_corosync_conf() device = None if cfg.has_quorum_device(): model, model_options, generic_options = cfg.get_quorum_device_settings() device = { "model": model, "model_options": model_options, "generic_options": generic_options, } return { "options": cfg.get_quorum_options(), "device": device, } def _check_if_atb_can_be_disabled( runner, report_processor, corosync_conf, was_enabled, force=False ): """ Check whenever auto_tie_breaker can be changed without affecting SBD. Raises LibraryError if change of ATB will affect SBD functionality. runner -- CommandRunner report_processor -- report processor corosync_conf -- corosync conf facade was_enabled -- True if ATB was enabled, False otherwise force -- force change """ if ( was_enabled and not corosync_conf.is_enabled_auto_tie_breaker() and sbd.is_auto_tie_breaker_needed(runner, corosync_conf) ): report_processor.process(reports.quorum_cannot_disable_atb_due_to_sbd( ReportItemSeverity.WARNING if force else ReportItemSeverity.ERROR, None if force else report_codes.FORCE_OPTIONS )) def set_options(lib_env, options, skip_offline_nodes=False, force=False): """ Set corosync quorum options, distribute and reload corosync.conf if live lib_env LibraryEnvironment options quorum options (dict) skip_offline_nodes continue even if not all nodes are accessible bool force force changes """ __ensure_not_cman(lib_env) cfg = lib_env.get_corosync_conf() atb_enabled = cfg.is_enabled_auto_tie_breaker() cfg.set_quorum_options(lib_env.report_processor, options) if lib_env.is_corosync_conf_live: _check_if_atb_can_be_disabled( lib_env.cmd_runner(), lib_env.report_processor, cfg, atb_enabled, force ) lib_env.push_corosync_conf(cfg, skip_offline_nodes) def status_text(lib_env): """ Get quorum runtime status in plain text """ __ensure_not_cman(lib_env) return corosync_live.get_quorum_status_text(lib_env.cmd_runner()) def status_device_text(lib_env, verbose=False): """ Get quorum device client runtime status in plain text bool verbose get more detailed output """ __ensure_not_cman(lib_env) return qdevice_client.get_status_text(lib_env.cmd_runner(), verbose) def add_device( lib_env, model, model_options, generic_options, force_model=False, force_options=False, skip_offline_nodes=False ): """ Add quorum device to cluster, distribute and reload configs if live model quorum device model model_options model specific options dict generic_options generic quorum device options dict force_model continue even if the model is not valid force_options continue even if options are not valid skip_offline_nodes continue even if not all nodes are accessible """ __ensure_not_cman(lib_env) cfg = lib_env.get_corosync_conf() # Try adding qdevice to corosync.conf. This validates all the options and # makes sure qdevice is not defined in corosync.conf yet. cfg.add_quorum_device( lib_env.report_processor, model, model_options, generic_options, force_model, force_options ) # First setup certificates for qdevice, then send corosync.conf to nodes. # If anything fails, nodes will not have corosync.conf with qdevice in it, # so there is no effect on the cluster. if lib_env.is_corosync_conf_live: # do model specific configuration # if model is not known to pcs and was forced, do not configure antyhing # else but corosync.conf, as we do not know what to do anyways if model == "net": _add_device_model_net( lib_env, # we are sure it's there, it was validated in add_quorum_device model_options["host"], cfg.get_cluster_name(), cfg.get_nodes(), skip_offline_nodes ) lib_env.report_processor.process( reports.service_enable_started("corosync-qdevice") ) communicator = lib_env.node_communicator() parallel_nodes_communication_helper( qdevice_client.remote_client_enable, [ [(lib_env.report_processor, communicator, node), {}] for node in cfg.get_nodes() ], lib_env.report_processor, skip_offline_nodes ) # everything set up, it's safe to tell the nodes to use qdevice lib_env.push_corosync_conf(cfg, skip_offline_nodes) # Now, when corosync.conf has been reloaded, we can start qdevice service. if lib_env.is_corosync_conf_live: lib_env.report_processor.process( reports.service_start_started("corosync-qdevice") ) communicator = lib_env.node_communicator() parallel_nodes_communication_helper( qdevice_client.remote_client_start, [ [(lib_env.report_processor, communicator, node), {}] for node in cfg.get_nodes() ], lib_env.report_processor, skip_offline_nodes ) def _add_device_model_net( lib_env, qnetd_host, cluster_name, cluster_nodes, skip_offline_nodes ): """ setup cluster nodes for using qdevice model net string qnetd_host address of qdevice provider (qnetd host) string cluster_name name of the cluster to which qdevice is being added NodeAddressesList cluster_nodes list of cluster nodes addresses bool skip_offline_nodes continue even if not all nodes are accessible """ communicator = lib_env.node_communicator() runner = lib_env.cmd_runner() reporter = lib_env.report_processor reporter.process( reports.qdevice_certificate_distribution_started() ) # get qnetd CA certificate try: qnetd_ca_cert = qdevice_net.remote_qdevice_get_ca_certificate( communicator, qnetd_host ) except NodeCommunicationException as e: raise LibraryError( node_communicator_exception_to_report_item(e) ) # init certificate storage on all nodes parallel_nodes_communication_helper( qdevice_net.remote_client_setup, [ ((communicator, node, qnetd_ca_cert), {}) for node in cluster_nodes ], reporter, skip_offline_nodes ) # create client certificate request cert_request = qdevice_net.client_generate_certificate_request( runner, cluster_name ) # sign the request on qnetd host try: signed_certificate = qdevice_net.remote_sign_certificate_request( communicator, qnetd_host, cert_request, cluster_name ) except NodeCommunicationException as e: raise LibraryError( node_communicator_exception_to_report_item(e) ) # transform the signed certificate to pk12 format which can sent to nodes pk12 = qdevice_net.client_cert_request_to_pk12(runner, signed_certificate) # distribute final certificate to nodes def do_and_report(reporter, communicator, node, pk12): qdevice_net.remote_client_import_certificate_and_key( communicator, node, pk12 ) reporter.process( reports.qdevice_certificate_accepted_by_node(node.label) ) parallel_nodes_communication_helper( do_and_report, [ ((reporter, communicator, node, pk12), {}) for node in cluster_nodes ], reporter, skip_offline_nodes ) def update_device( lib_env, model_options, generic_options, force_options=False, skip_offline_nodes=False ): """ Change quorum device settings, distribute and reload configs if live model_options model specific options dict generic_options generic quorum device options dict force_options continue even if options are not valid skip_offline_nodes continue even if not all nodes are accessible """ __ensure_not_cman(lib_env) cfg = lib_env.get_corosync_conf() cfg.update_quorum_device( lib_env.report_processor, model_options, generic_options, force_options ) lib_env.push_corosync_conf(cfg, skip_offline_nodes) def remove_device(lib_env, skip_offline_nodes=False): """ Stop using quorum device, distribute and reload configs if live skip_offline_nodes continue even if not all nodes are accessible """ __ensure_not_cman(lib_env) cfg = lib_env.get_corosync_conf() model, dummy_options, dummy_options = cfg.get_quorum_device_settings() cfg.remove_quorum_device() if lib_env.is_corosync_conf_live: communicator = lib_env.node_communicator() # fix quorum options for SBD to work properly if sbd.atb_has_to_be_enabled(lib_env.cmd_runner(), cfg): lib_env.report_processor.process(reports.sbd_requires_atb()) cfg.set_quorum_options( lib_env.report_processor, {"auto_tie_breaker": "1"} ) # disable qdevice lib_env.report_processor.process( reports.service_disable_started("corosync-qdevice") ) parallel_nodes_communication_helper( qdevice_client.remote_client_disable, [ [(lib_env.report_processor, communicator, node), {}] for node in cfg.get_nodes() ], lib_env.report_processor, skip_offline_nodes ) # stop qdevice lib_env.report_processor.process( reports.service_stop_started("corosync-qdevice") ) parallel_nodes_communication_helper( qdevice_client.remote_client_stop, [ [(lib_env.report_processor, communicator, node), {}] for node in cfg.get_nodes() ], lib_env.report_processor, skip_offline_nodes ) # handle model specific configuration if model == "net": _remove_device_model_net( lib_env, cfg.get_nodes(), skip_offline_nodes ) lib_env.push_corosync_conf(cfg, skip_offline_nodes) def _remove_device_model_net(lib_env, cluster_nodes, skip_offline_nodes): """ remove configuration used by qdevice model net NodeAddressesList cluster_nodes list of cluster nodes addresses bool skip_offline_nodes continue even if not all nodes are accessible """ reporter = lib_env.report_processor communicator = lib_env.node_communicator() reporter.process( reports.qdevice_certificate_removal_started() ) def do_and_report(reporter, communicator, node): qdevice_net.remote_client_destroy(communicator, node) reporter.process( reports.qdevice_certificate_removed_from_node(node.label) ) parallel_nodes_communication_helper( do_and_report, [ [(reporter, communicator, node), {}] for node in cluster_nodes ], lib_env.report_processor, skip_offline_nodes ) def set_expected_votes_live(lib_env, expected_votes): """ set expected votes in live cluster to specified value numeric expected_votes desired value of expected votes """ if lib_env.is_cman_cluster: raise LibraryError(reports.cman_unsupported_command()) try: votes_int = int(expected_votes) if votes_int < 1: raise ValueError() except ValueError: raise LibraryError(reports.invalid_option_value( "expected votes", expected_votes, "positive integer" )) corosync_live.set_expected_votes(lib_env.cmd_runner(), votes_int) def __ensure_not_cman(lib_env): if lib_env.is_corosync_conf_live and lib_env.is_cman_cluster: raise LibraryError(reports.cman_unsupported_command()) pcs-0.9.155/pcs/lib/commands/resource_agent.py000066400000000000000000000064341301012375000211720ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.lib import resource_agent def list_standards(lib_env): """ List resource agents standards (ocf, lsb, ... ) on the local host """ return resource_agent.list_resource_agents_standards(lib_env.cmd_runner()) def list_ocf_providers(lib_env): """ List resource agents ocf providers on the local host """ return resource_agent.list_resource_agents_ocf_providers( lib_env.cmd_runner() ) def list_agents_for_standard_and_provider(lib_env, standard_provider=None): """ List resource agents for specified standard on the local host string standard_provider standard[:provider], e.g. None, ocf, ocf:pacemaker """ if standard_provider: standards = [standard_provider] else: standards = resource_agent.list_resource_agents_standards( lib_env.cmd_runner() ) agents = [] for std in standards: agents += resource_agent.list_resource_agents(lib_env.cmd_runner(), std) return sorted( agents, # works with both str and unicode in both python 2 and 3 key=lambda x: x.lower() ) def list_agents(lib_env, describe=True, search=None): """ List all resource agents on the local host, optionally filtered and described bool describe load and return agents' description as well string search return only agents which name contains this string """ runner = lib_env.cmd_runner() # list agents for all standards and providers agent_names = [] for std in resource_agent.list_resource_agents_standards_and_providers( runner ): agent_names += [ "{0}:{1}".format(std, agent) for agent in resource_agent.list_resource_agents(runner, std) ] agent_names.sort( # works with both str and unicode in both python 2 and 3 key=lambda x: x.lower() ) return _complete_agent_list( runner, agent_names, describe, search, resource_agent.ResourceAgent ) def _complete_agent_list( runner, agent_names, describe, search, metadata_class ): # filter agents by name if requested if search: search_lower = search.lower() agent_names = [ name for name in agent_names if search_lower in name.lower() ] # complete the output and load descriptions if requested agent_list = [] for name in agent_names: try: agent_metadata = metadata_class(runner, name) if describe: agent_list.append(agent_metadata.get_description_info()) else: agent_list.append(agent_metadata.get_name_info()) except resource_agent.UnableToGetAgentMetadata: # if we cannot get valid metadata, it's not a resource agent and # we don't return it in the list pass return agent_list def describe_agent(lib_env, agent_name): """ Get agent's description (metadata) in a structure string agent_name name of the agent """ agent = resource_agent.find_valid_resource_agent_by_name( lib_env.report_processor, lib_env.cmd_runner(), agent_name, ) return agent.get_full_info() pcs-0.9.155/pcs/lib/commands/sbd.py000066400000000000000000000277421301012375000167420ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os import json from pcs import settings from pcs.common import ( tools, report_codes, ) from pcs.lib import ( sbd, reports, nodes_task, ) from pcs.lib.tools import environment_file_to_dict from pcs.lib.errors import ( LibraryError, ReportItemSeverity as Severities ) from pcs.lib.external import ( node_communicator_exception_to_report_item, NodeCommunicationException, NodeConnectionException, NodeCommandUnsuccessfulException, ) from pcs.lib.node import ( NodeAddressesList, NodeNotFound ) def _validate_sbd_options(sbd_config, allow_unknown_opts=False): """ Validate user SBD configuration. Options 'SBD_WATCHDOG_DEV' and 'SBD_OPTS' are restricted. Returns list of ReportItem sbd_config -- dictionary in format: : allow_unknown_opts -- if True, accept also unknown options. """ report_item_list = [] unsupported_sbd_option_list = [ "SBD_WATCHDOG_DEV", "SBD_OPTS", "SBD_PACEMAKER" ] allowed_sbd_options = [ "SBD_DELAY_START", "SBD_STARTMODE", "SBD_WATCHDOG_TIMEOUT" ] for sbd_opt in sbd_config: if sbd_opt in unsupported_sbd_option_list: report_item_list.append(reports.invalid_option( sbd_opt, allowed_sbd_options, None )) elif sbd_opt not in allowed_sbd_options: report_item_list.append(reports.invalid_option( sbd_opt, allowed_sbd_options, None, Severities.WARNING if allow_unknown_opts else Severities.ERROR, None if allow_unknown_opts else report_codes.FORCE_OPTIONS )) if "SBD_WATCHDOG_TIMEOUT" in sbd_config: report_item = reports.invalid_option_value( "SBD_WATCHDOG_TIMEOUT", sbd_config["SBD_WATCHDOG_TIMEOUT"], "nonnegative integer" ) try: if int(sbd_config["SBD_WATCHDOG_TIMEOUT"]) < 0: report_item_list.append(report_item) except (ValueError, TypeError): report_item_list.append(report_item) return report_item_list def _get_full_watchdog_list(node_list, default_watchdog, watchdog_dict): """ Validate if all nodes in watchdog_dict does exist and returns dictionary where keys are nodes and value is corresponding watchdog. Raises LibraryError if any of nodes doesn't belong to cluster. node_list -- NodeAddressesList default_watchdog -- watchdog for nodes which are not specified in watchdog_dict watchdog_dict -- dictionary with node names as keys and value as watchdog """ full_dict = dict([(node, default_watchdog) for node in node_list]) report_item_list = [] for node_name, watchdog in watchdog_dict.items(): if not watchdog or not os.path.isabs(watchdog): report_item_list.append(reports.invalid_watchdog_path(watchdog)) continue try: full_dict[node_list.find_by_label(node_name)] = watchdog except NodeNotFound: report_item_list.append(reports.node_not_found(node_name)) if report_item_list: raise LibraryError(*report_item_list) return full_dict def enable_sbd( lib_env, default_watchdog, watchdog_dict, sbd_options, allow_unknown_opts=False, ignore_offline_nodes=False ): """ Enable SBD on all nodes in cluster. lib_env -- LibraryEnvironment default_watchdog -- watchdog for nodes which are not specified in watchdog_dict. Uses default value from settings if None. watchdog_dict -- dictionary with NodeAddresses as keys and watchdog path as value sbd_options -- dictionary in format: : allow_unknown_opts -- if True, accept also unknown options. ignore_offline_nodes -- if True, omit offline nodes """ node_list = _get_cluster_nodes(lib_env) if not default_watchdog: default_watchdog = settings.sbd_watchdog_default # input validation begin full_watchdog_dict = _get_full_watchdog_list( node_list, default_watchdog, watchdog_dict ) # config validation sbd_options = dict([(opt.upper(), val) for opt, val in sbd_options.items()]) lib_env.report_processor.process_list( _validate_sbd_options(sbd_options, allow_unknown_opts) ) # check nodes status online_nodes = _get_online_nodes(lib_env, node_list, ignore_offline_nodes) for node in list(full_watchdog_dict): if node not in online_nodes: full_watchdog_dict.pop(node, None) # input validation end # check if SBD can be enabled sbd.check_sbd_on_all_nodes( lib_env.report_processor, lib_env.node_communicator(), full_watchdog_dict ) # enable ATB if needed if not lib_env.is_cman_cluster: corosync_conf = lib_env.get_corosync_conf() if sbd.atb_has_to_be_enabled_pre_enable_check(corosync_conf): lib_env.report_processor.process(reports.sbd_requires_atb()) corosync_conf.set_quorum_options( lib_env.report_processor, {"auto_tie_breaker": "1"} ) lib_env.push_corosync_conf(corosync_conf, ignore_offline_nodes) # distribute SBD configuration config = sbd.get_default_sbd_config() config.update(sbd_options) sbd.set_sbd_config_on_all_nodes( lib_env.report_processor, lib_env.node_communicator(), online_nodes, config, full_watchdog_dict ) # remove cluster prop 'stonith_watchdog_timeout' sbd.remove_stonith_watchdog_timeout_on_all_nodes( lib_env.node_communicator(), online_nodes ) # enable SBD service an all nodes sbd.enable_sbd_service_on_all_nodes( lib_env.report_processor, lib_env.node_communicator(), online_nodes ) lib_env.report_processor.process( reports.cluster_restart_required_to_apply_changes() ) def disable_sbd(lib_env, ignore_offline_nodes=False): """ Disable SBD on all nodes in cluster. lib_env -- LibraryEnvironment ignore_offline_nodes -- if True, omit offline nodes """ node_list = _get_online_nodes( lib_env, _get_cluster_nodes(lib_env), ignore_offline_nodes ) if lib_env.is_cman_cluster: nodes_task.check_corosync_offline_on_nodes( lib_env.node_communicator(), lib_env.report_processor, node_list, ignore_offline_nodes ) sbd.set_stonith_watchdog_timeout_to_zero_on_all_nodes( lib_env.node_communicator(), node_list ) sbd.disable_sbd_service_on_all_nodes( lib_env.report_processor, lib_env.node_communicator(), node_list ) if not lib_env.is_cman_cluster: lib_env.report_processor.process( reports.cluster_restart_required_to_apply_changes() ) def _get_online_nodes(lib_env, node_list, ignore_offline_nodes=False): """ Returns NodeAddressesList of online nodes. Raises LibraryError on any failure. lib_env -- LibraryEnvironment node_list -- NodeAddressesList ignore_offline_nodes -- if True offline nodes are just omitted from returned list. """ to_raise = [] online_node_list = NodeAddressesList() def is_node_online(node): try: nodes_task.node_check_auth(lib_env.node_communicator(), node) online_node_list.append(node) except NodeConnectionException as e: if ignore_offline_nodes: to_raise.append(reports.omitting_node(node.label)) else: to_raise.append(node_communicator_exception_to_report_item( e, Severities.ERROR, report_codes.SKIP_OFFLINE_NODES )) except NodeCommunicationException as e: to_raise.append(node_communicator_exception_to_report_item(e)) tools.run_parallel(is_node_online, [([node], {}) for node in node_list]) lib_env.report_processor.process_list(to_raise) return online_node_list def get_cluster_sbd_status(lib_env): """ Returns status of SBD service in cluster in dictionary with format: { : { "installed": , "enabled": , "running": }, ... } lib_env -- LibraryEnvironment """ node_list = _get_cluster_nodes(lib_env) report_item_list = [] successful_node_list = [] status_list = [] def get_sbd_status(node): try: status_list.append({ "node": node, "status": json.loads( sbd.check_sbd(lib_env.node_communicator(), node, "") )["sbd"] }) successful_node_list.append(node) except NodeCommunicationException as e: report_item_list.append(node_communicator_exception_to_report_item( e, severity=Severities.WARNING )) report_item_list.append(reports.unable_to_get_sbd_status( node.label, "", #reason is in previous report item #warning is there implicit )) except (ValueError, KeyError) as e: report_item_list.append(reports.unable_to_get_sbd_status( node.label, str(e) )) tools.run_parallel(get_sbd_status, [([node], {}) for node in node_list]) lib_env.report_processor.process_list(report_item_list) for node in node_list: if node not in successful_node_list: status_list.append({ "node": node, "status": { "installed": None, "enabled": None, "running": None } }) return status_list def get_cluster_sbd_config(lib_env): """ Returns list of SBD config from all cluster nodes in cluster. Structure of data: [ { "node": "config": or None if there was failure, }, ... ] If error occurs while obtaining config from some node, it's config will be None. If obtaining config fail on all node returns empty dictionary. lib_env -- LibraryEnvironment """ node_list = _get_cluster_nodes(lib_env) config_list = [] successful_node_list = [] report_item_list = [] def get_sbd_config(node): try: config_list.append({ "node": node, "config": environment_file_to_dict( sbd.get_sbd_config(lib_env.node_communicator(), node) ) }) successful_node_list.append(node) except NodeCommandUnsuccessfulException as e: report_item_list.append(reports.unable_to_get_sbd_config( node.label, e.reason, Severities.WARNING )) except NodeCommunicationException as e: report_item_list.append(node_communicator_exception_to_report_item( e, severity=Severities.WARNING )) report_item_list.append(reports.unable_to_get_sbd_config( node.label, "", #reason is in previous report item Severities.WARNING )) tools.run_parallel(get_sbd_config, [([node], {}) for node in node_list]) lib_env.report_processor.process_list(report_item_list) if not len(config_list): return [] for node in node_list: if node not in successful_node_list: config_list.append({ "node": node, "config": None }) return config_list def get_local_sbd_config(lib_env): return environment_file_to_dict(sbd.get_local_sbd_config()) def _get_cluster_nodes(lib_env): if lib_env.is_cman_cluster: return lib_env.get_cluster_conf().get_nodes() else: return lib_env.get_corosync_conf().get_nodes() pcs-0.9.155/pcs/lib/commands/stonith_agent.py000066400000000000000000000023761301012375000210340ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.lib import resource_agent from pcs.lib.commands.resource_agent import _complete_agent_list from pcs.lib.errors import LibraryError def list_agents(lib_env, describe=True, search=None): """ List all stonith agents on the local host, optionally filtered and described bool describe load and return agents' description as well string search return only agents which name contains this string """ runner = lib_env.cmd_runner() agent_names = resource_agent.list_stonith_agents(runner) return _complete_agent_list( runner, agent_names, describe, search, resource_agent.StonithAgent ) def describe_agent(lib_env, agent_name): """ Get agent's description (metadata) in a structure string agent_name name of the agent (not containing "stonith:" prefix) """ try: metadata = resource_agent.StonithAgent( lib_env.cmd_runner(), agent_name ) return metadata.get_full_info() except resource_agent.ResourceAgentError as e: raise LibraryError( resource_agent.resource_agent_error_to_report_item(e) ) pcs-0.9.155/pcs/lib/commands/test/000077500000000000000000000000001301012375000165635ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/commands/test/__init__.py000066400000000000000000000000001301012375000206620ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/commands/test/test_acl.py000066400000000000000000000465251301012375000207470ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.assertions import ( assert_raise_library_error, ExtendedAssertionsMixin, ) from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.test.tools.pcs_unittest import mock, TestCase from pcs.common import report_codes from pcs.lib.errors import ( LibraryError, ReportItemSeverity as Severities, ) from pcs.lib.env import LibraryEnvironment import pcs.lib.commands.acl as cmd_acl import pcs.lib.cib.acl as acl_lib REQUIRED_CIB_VERSION = (2, 0, 0) class AclCommandsTest(TestCase, ExtendedAssertionsMixin): def setUp(self): self.mock_rep = MockLibraryReportProcessor() self.mock_env = mock.MagicMock(spec_set=LibraryEnvironment) self.mock_env.report_processor = self.mock_rep self.cib = "cib" self.mock_env.get_cib.return_value = self.cib def assert_get_cib_called(self): self.mock_env.get_cib.assert_called_once_with(REQUIRED_CIB_VERSION) def assert_same_cib_pushed(self): self.mock_env.push_cib.assert_called_once_with(self.cib) def assert_cib_not_pushed(self): self.assertEqual(0, self.mock_env.push_cib.call_count) @mock.patch("pcs.lib.cib.acl.validate_permissions") @mock.patch("pcs.lib.cib.acl.create_role") @mock.patch("pcs.lib.cib.acl.add_permissions_to_role") class CreateRoleTest(AclCommandsTest): def test_success(self, mock_add_perm, mock_create_role, mock_validate): perm_list = ["my", "list"] mock_create_role.return_value = "role el" cmd_acl.create_role(self.mock_env, "role_id", perm_list, "desc") self.assert_get_cib_called() mock_validate.assert_called_once_with(self.cib, perm_list) mock_create_role.assert_called_once_with(self.cib, "role_id", "desc") mock_add_perm.assert_called_once_with("role el", perm_list) self.assert_same_cib_pushed() def test_no_permission( self, mock_add_perm, mock_create_role, mock_validate ): mock_create_role.return_value = "role el" cmd_acl.create_role(self.mock_env, "role_id", [], "desc") self.assert_get_cib_called() self.assertEqual(0, mock_validate.call_count) mock_create_role.assert_called_once_with(self.cib, "role_id", "desc") self.assertEqual(0, mock_add_perm.call_count) self.assert_same_cib_pushed() @mock.patch("pcs.lib.cib.acl.remove_role") class RemoveRoleTest(AclCommandsTest): def test_success_no_autodelete(self, mock_remove): cmd_acl.remove_role(self.mock_env, "role_id", False) self.assert_get_cib_called() mock_remove.assert_called_once_with(self.cib, "role_id", False) self.assert_same_cib_pushed() def test_success_autodelete(self, mock_remove): cmd_acl.remove_role(self.mock_env, "role_id", True) self.assert_get_cib_called() mock_remove.assert_called_once_with(self.cib, "role_id", True) self.assert_same_cib_pushed() def test_role_not_found(self, mock_remove): mock_remove.side_effect = acl_lib.AclRoleNotFound("role_id") assert_raise_library_error( lambda: cmd_acl.remove_role(self.mock_env, "role_id", True), ( Severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "role_id", "id_description": "role", } ) ) self.assert_get_cib_called() mock_remove.assert_called_once_with(self.cib, "role_id", True) self.assert_cib_not_pushed() @mock.patch("pcs.lib.commands.acl._get_target_or_group") @mock.patch("pcs.lib.cib.acl.assign_role") @mock.patch("pcs.lib.cib.acl.find_role") @mock.patch("pcs.lib.cib.acl.acl_error_to_report_item") class AssignRoleNotSpecific(AclCommandsTest, ExtendedAssertionsMixin): def test_success( self, mock_error_convert, mock_find_role, mock_assign, mock_get_tg ): mock_get_tg.return_value = "target_el" mock_find_role.return_value = "role_el" cmd_acl.assign_role_not_specific(self.mock_env, "role_id", "target_id") self.assert_get_cib_called() mock_get_tg.assert_called_once_with(self.cib, "target_id") mock_find_role.assert_called_once_with(self.cib, "role_id") mock_assign.assert_called_once_with("target_el", "role_el") self.assertEqual(0, mock_error_convert.call_count) self.assert_same_cib_pushed() def test_failure( self, mock_error_convert, mock_find_role, mock_assign, mock_get_tg ): mock_get_tg.return_value = "target_el" exception_obj = acl_lib.AclRoleNotFound("role_id") mock_find_role.side_effect = exception_obj self.assert_raises( LibraryError, lambda: cmd_acl.assign_role_not_specific( self.mock_env, "role_id", "target_id" ) ) self.assert_get_cib_called() self.assertEqual(0, mock_assign.call_count) mock_error_convert.assert_called_once_with(exception_obj) self.assert_cib_not_pushed() @mock.patch("pcs.lib.cib.acl.find_target") @mock.patch("pcs.lib.cib.acl.find_group") class GetTargetOrGroupTest(AclCommandsTest): def test_target(self, mock_find_group, mock_find_target): mock_find_target.return_value = "target_el" self.assertEqual( "target_el", cmd_acl._get_target_or_group(self.cib, "target_id") ) mock_find_target.assert_called_once_with(self.cib, "target_id") self.assertEqual(0, mock_find_group.call_count) def test_group(self, mock_find_group, mock_find_target): mock_find_target.side_effect = acl_lib.AclTargetNotFound("group_id") mock_find_group.return_value = "group_el" self.assertEqual( "group_el", cmd_acl._get_target_or_group(self.cib, "group_id") ) mock_find_target.assert_called_once_with(self.cib, "group_id") mock_find_group.assert_called_once_with(self.cib, "group_id") def test_not_found(self, mock_find_group, mock_find_target): mock_find_target.side_effect = acl_lib.AclTargetNotFound("id") mock_find_group.side_effect = acl_lib.AclGroupNotFound("id") assert_raise_library_error( lambda: cmd_acl._get_target_or_group(self.cib, "id"), ( Severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "id", "id_description": "user/group", } ) ) mock_find_target.assert_called_once_with(self.cib, "id") mock_find_group.assert_called_once_with(self.cib, "id") @mock.patch("pcs.lib.cib.acl.assign_role") @mock.patch("pcs.lib.cib.acl.find_role") @mock.patch("pcs.lib.cib.acl.find_target") @mock.patch("pcs.lib.cib.acl.acl_error_to_report_item") class AssignRoleToTargetTest(AclCommandsTest): def test_success( self, mock_error_convert, mock_target, mock_role, mock_assign ): mock_target.return_value = "target_el" mock_role.return_value = "role_el" cmd_acl.assign_role_to_target(self.mock_env, "role_id", "target_id") self.assert_get_cib_called() mock_target.assert_called_once_with(self.cib, "target_id") mock_role.assert_called_once_with(self.cib, "role_id") mock_assign.assert_called_once_with("target_el", "role_el") self.assert_same_cib_pushed() self.assertEqual(0, mock_error_convert.call_count) def test_failure( self, mock_error_convert, mock_target, mock_role, mock_assign ): exception_obj = acl_lib.AclTargetNotFound("target_id") mock_target.side_effect = exception_obj mock_role.return_value = "role_el" self.assert_raises( LibraryError, lambda: cmd_acl.assign_role_to_target( self.mock_env, "role_id", "target_id" ) ) self.assert_get_cib_called() mock_target.assert_called_once_with(self.cib, "target_id") mock_error_convert.assert_called_once_with(exception_obj) self.assertEqual(0, mock_assign.call_count) self.assert_cib_not_pushed() @mock.patch("pcs.lib.cib.acl.assign_role") @mock.patch("pcs.lib.cib.acl.find_role") @mock.patch("pcs.lib.cib.acl.find_group") @mock.patch("pcs.lib.cib.acl.acl_error_to_report_item") class AssignRoleToGroupTest(AclCommandsTest): def test_success( self, mock_error_convert, mock_group, mock_role, mock_assign ): mock_group.return_value = "group_el" mock_role.return_value = "role_el" cmd_acl.assign_role_to_group(self.mock_env, "role_id", "group_id") self.assert_get_cib_called() mock_group.assert_called_once_with(self.cib, "group_id") mock_role.assert_called_once_with(self.cib, "role_id") mock_assign.assert_called_once_with("group_el", "role_el") self.assert_same_cib_pushed() self.assertEqual(0, mock_error_convert.call_count) def test_failure( self, mock_error_convert, mock_group, mock_role, mock_assign ): exception_obj = acl_lib.AclGroupNotFound("group_id") mock_group.side_effect = exception_obj mock_role.return_value = "role_el" self.assert_raises( LibraryError, lambda: cmd_acl.assign_role_to_group( self.mock_env, "role_id", "group_id" ) ) self.assert_get_cib_called() mock_group.assert_called_once_with(self.cib, "group_id") mock_error_convert.assert_called_once_with(exception_obj) self.assertEqual(0, mock_assign.call_count) self.assert_cib_not_pushed() @mock.patch("pcs.lib.commands.acl._get_target_or_group") @mock.patch("pcs.lib.cib.acl.unassign_role") class UnassignRoleNotSpecificTest(AclCommandsTest): def test_success(self, mock_unassign, mock_tg): mock_tg.return_value = "target_el" cmd_acl.unassign_role_not_specific( self.mock_env, "role_id", "target_id", False ) self.assert_get_cib_called() mock_tg.assert_called_once_with(self.cib, "target_id") mock_unassign.assert_called_once_with("target_el", "role_id", False) self.assert_same_cib_pushed() def test_success_with_autodelete(self, mock_unassign, mock_tg): mock_tg.return_value = "target_el" cmd_acl.unassign_role_not_specific( self.mock_env, "role_id", "target_id", True ) self.assert_get_cib_called() mock_tg.assert_called_once_with(self.cib, "target_id") mock_unassign.assert_called_once_with("target_el", "role_id", True) self.assert_same_cib_pushed() @mock.patch("pcs.lib.cib.acl.unassign_role") @mock.patch("pcs.lib.cib.acl.find_target") @mock.patch("pcs.lib.cib.acl.acl_error_to_report_item") class UnassignRoleFromTargetTest(AclCommandsTest): def test_success(self, mock_error_convert, mock_find_el, mock_unassign): mock_find_el.return_value = "el" cmd_acl.unassign_role_from_target( self.mock_env, "role_id", "el_id", False ) self.assert_get_cib_called() mock_find_el.assert_called_once_with(self.cib, "el_id") mock_unassign.assert_called_once_with("el", "role_id", False) self.assert_same_cib_pushed() self.assertEqual(0, mock_error_convert.call_count) def test_success_autodelete( self, mock_error_convert, mock_find_el, mock_unassign ): mock_find_el.return_value = "el" cmd_acl.unassign_role_from_target( self.mock_env, "role_id", "el_id", True ) self.assert_get_cib_called() mock_find_el.assert_called_once_with(self.cib, "el_id") mock_unassign.assert_called_once_with("el", "role_id", True) self.assert_same_cib_pushed() self.assertEqual(0, mock_error_convert.call_count) def test_failure(self, mock_error_convert, mock_find_el, mock_unassign): exception_obj = acl_lib.AclTargetNotFound("el_id") mock_find_el.side_effect = exception_obj self.assert_raises( LibraryError, lambda: cmd_acl.unassign_role_from_target( self.mock_env, "role_id", "el_id", False ) ) self.assert_get_cib_called() mock_find_el.assert_called_once_with(self.cib, "el_id") self.assertEqual(0, mock_unassign.call_count) self.assert_cib_not_pushed() mock_error_convert.assert_called_once_with(exception_obj) @mock.patch("pcs.lib.cib.acl.unassign_role") @mock.patch("pcs.lib.cib.acl.find_group") @mock.patch("pcs.lib.cib.acl.acl_error_to_report_item") class UnassignRoleFromGroupTest(AclCommandsTest): def test_success(self, mock_error_convert, mock_find_el, mock_unassign): mock_find_el.return_value = "el" cmd_acl.unassign_role_from_group( self.mock_env, "role_id", "el_id", False ) self.assert_get_cib_called() mock_find_el.assert_called_once_with(self.cib, "el_id") mock_unassign.assert_called_once_with("el", "role_id", False) self.assert_same_cib_pushed() self.assertEqual(0, mock_error_convert.call_count) def test_success_autodelete( self, mock_error_convert, mock_find_el, mock_unassign ): mock_find_el.return_value = "el" cmd_acl.unassign_role_from_group( self.mock_env, "role_id", "el_id", True ) self.assert_get_cib_called() mock_find_el.assert_called_once_with(self.cib, "el_id") mock_unassign.assert_called_once_with("el", "role_id", True) self.assert_same_cib_pushed() self.assertEqual(0, mock_error_convert.call_count) def test_failure(self, mock_error_convert, mock_find_el, mock_unassign): exception_obj = acl_lib.AclGroupNotFound("el_id") mock_find_el.side_effect = exception_obj self.assert_raises( LibraryError, lambda: cmd_acl.unassign_role_from_group( self.mock_env, "role_id", "el_id", False ) ) self.assert_get_cib_called() mock_find_el.assert_called_once_with(self.cib, "el_id") self.assertEqual(0, mock_unassign.call_count) self.assert_cib_not_pushed() mock_error_convert.assert_called_once_with(exception_obj) @mock.patch("pcs.lib.cib.acl.assign_role") @mock.patch("pcs.lib.cib.acl.find_role") class AssignRolesToElement(AclCommandsTest): def test_success(self, mock_role, mock_assign): mock_role.side_effect = lambda _, el_id: "{0}_el".format(el_id) cmd_acl._assign_roles_to_element( self.cib, "el", ["role1", "role2", "role3"] ) mock_role.assert_has_calls([ mock.call(self.cib, "role1"), mock.call(self.cib, "role2"), mock.call(self.cib, "role3") ]) mock_assign.assert_has_calls([ mock.call("el", "role1_el"), mock.call("el", "role2_el"), mock.call("el", "role3_el") ]) def test_failure(self, mock_role, mock_assign): def _mock_role(_, el_id): if el_id in ["role1", "role3"]: raise acl_lib.AclRoleNotFound(el_id) elif el_id == "role2": return "role2_el" else: raise AssertionError("unexpected input") mock_role.side_effect = _mock_role assert_raise_library_error( lambda: cmd_acl._assign_roles_to_element( self.cib, "el", ["role1", "role2", "role3"] ), ( Severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "role1", "id_description": "role", } ), ( Severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "role3", "id_description": "role", } ) ) mock_role.assert_has_calls([ mock.call(self.cib, "role1"), mock.call(self.cib, "role2"), mock.call(self.cib, "role3") ]) mock_assign.assert_called_once_with("el", "role2_el") @mock.patch("pcs.lib.cib.acl.create_target") @mock.patch("pcs.lib.commands.acl._assign_roles_to_element") class CreateTargetTest(AclCommandsTest): def test_success(self, mock_assign, mock_create): mock_create.return_value = "el" cmd_acl.create_target( self.mock_env, "el_id", ["role1", "role2", "role3"] ) self.assert_get_cib_called() mock_create.assert_called_once_with(self.cib, "el_id") mock_assign(self.cib, "el", ["role1", "role2", "role3"]) self.assert_same_cib_pushed() @mock.patch("pcs.lib.cib.acl.create_group") @mock.patch("pcs.lib.commands.acl._assign_roles_to_element") class CreateGroupTest(AclCommandsTest): def test_success(self, mock_assign, mock_create): mock_create.return_value = "el" cmd_acl.create_group( self.mock_env, "el_id", ["role1", "role2", "role3"] ) self.assert_get_cib_called() mock_create.assert_called_once_with(self.cib, "el_id") mock_assign(self.cib, "el", ["role1", "role2", "role3"]) self.assert_same_cib_pushed() @mock.patch("pcs.lib.cib.acl.remove_target") class RemoveTargetTest(AclCommandsTest): def test_success(self, mock_remove): cmd_acl.remove_target(self.mock_env, "el_id") self.assert_get_cib_called() mock_remove.assert_called_once_with(self.cib, "el_id") self.assert_same_cib_pushed() @mock.patch("pcs.lib.cib.acl.remove_group") class RemoveGroupTest(AclCommandsTest): def test_success(self, mock_remove): cmd_acl.remove_group(self.mock_env, "el_id") self.assert_get_cib_called() mock_remove.assert_called_once_with(self.cib, "el_id") self.assert_same_cib_pushed() @mock.patch("pcs.lib.cib.acl.validate_permissions") @mock.patch("pcs.lib.cib.acl.provide_role") @mock.patch("pcs.lib.cib.acl.add_permissions_to_role") class AddPermissionTest(AclCommandsTest): def test_success(self, mock_add_perm, mock_provide_role, mock_validate): mock_provide_role.return_value = "role_el" cmd_acl.add_permission(self.mock_env, "role_id", "permission_list") self.assert_get_cib_called() mock_validate.assert_called_once_with(self.cib, "permission_list") mock_provide_role.assert_called_once_with(self.cib, "role_id") mock_add_perm.assert_called_once_with("role_el", "permission_list") self.assert_same_cib_pushed() @mock.patch("pcs.lib.cib.acl.remove_permission") class RemovePermission(AclCommandsTest): def test_success(self, mock_remove): cmd_acl.remove_permission(self.mock_env, "id") self.assert_get_cib_called() mock_remove.assert_called_once_with(self.cib, "id") self.assert_same_cib_pushed() @mock.patch("pcs.lib.cib.acl.get_target_list") @mock.patch("pcs.lib.cib.acl.get_group_list") @mock.patch("pcs.lib.cib.acl.get_role_list") class GetConfigTest(AclCommandsTest): def test_success(self, mock_role, mock_group, mock_target): mock_role.return_value = "role" mock_group.return_value = "group" mock_target.return_value = "target" self.assertEqual( { "target_list": "target", "group_list": "group", "role_list": "role", }, cmd_acl.get_config(self.mock_env) ) pcs-0.9.155/pcs/lib/commands/test/test_alert.py000066400000000000000000000635631301012375000213200ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import logging from lxml import etree from pcs.test.tools.pcs_unittest import TestCase from pcs.test.tools.pcs_unittest import mock from pcs.test.tools.assertions import ( assert_raise_library_error, assert_xml_equal, assert_report_item_list_equal, ) from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.common import report_codes from pcs.lib.errors import ReportItemSeverity as Severities from pcs.lib.env import LibraryEnvironment from pcs.lib.external import CommandRunner import pcs.lib.commands.alert as cmd_alert @mock.patch("pcs.lib.cib.tools.upgrade_cib") class CreateAlertTest(TestCase): def setUp(self): self.mock_log = mock.MagicMock(spec_set=logging.Logger) self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_rep = MockLibraryReportProcessor() self.mock_env = LibraryEnvironment( self.mock_log, self.mock_rep, cib_data="" ) def test_no_path(self, mock_upgrade_cib): assert_raise_library_error( lambda: cmd_alert.create_alert( self.mock_env, None, None, None, None ), ( Severities.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, {"option_name": "path"} ) ) self.assertEqual(0, mock_upgrade_cib.call_count) def test_upgrade_needed(self, mock_upgrade_cib): self.mock_env._push_cib_xml( """ """ ) mock_upgrade_cib.return_value = etree.XML( """ """ ) cmd_alert.create_alert( self.mock_env, "my-alert", "/my/path", { "instance": "value", "another": "val" }, {"meta1": "val1"}, "my description" ) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) self.assertEqual(1, mock_upgrade_cib.call_count) class UpdateAlertTest(TestCase): def setUp(self): self.mock_log = mock.MagicMock(spec_set=logging.Logger) self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_rep = MockLibraryReportProcessor() self.mock_env = LibraryEnvironment( self.mock_log, self.mock_rep, cib_data="" ) def test_update_all(self): self.mock_env._push_cib_xml( """ """ ) cmd_alert.update_alert( self.mock_env, "my-alert", "/another/one", { "instance": "", "my-attr": "its_val" }, {"meta1": "val2"}, "" ) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) def test_update_instance_attribute(self): self.mock_env._push_cib_xml( """ """ ) cmd_alert.update_alert( self.mock_env, "my-alert", None, {"instance": "new_val"}, {}, None ) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) def test_alert_doesnt_exist(self): self.mock_env._push_cib_xml( """ """ ) assert_raise_library_error( lambda: cmd_alert.update_alert( self.mock_env, "unknown", "test", {}, {}, None ), ( Severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, {"alert": "unknown"} ) ) class RemoveAlertTest(TestCase): def setUp(self): self.mock_log = mock.MagicMock(spec_set=logging.Logger) self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_rep = MockLibraryReportProcessor() cib = """ """ self.mock_env = LibraryEnvironment( self.mock_log, self.mock_rep, cib_data=cib ) def test_one_alert(self): cmd_alert.remove_alert(self.mock_env, ["alert2"]) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) self.assertEqual([], self.mock_rep.report_item_list) def test_multiple_alerts(self): cmd_alert.remove_alert(self.mock_env, ["alert1", "alert3", "alert4"]) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) self.assertEqual([], self.mock_rep.report_item_list) def test_no_alert(self): cmd_alert.remove_alert(self.mock_env, []) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) self.assertEqual([], self.mock_rep.report_item_list) def test_failure(self): report_list = [ ( Severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, {"alert": "unknown"} ), ( Severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, {"alert": "unknown2"} ) ] assert_raise_library_error( lambda: cmd_alert.remove_alert( self.mock_env, ["unknown", "alert1", "unknown2", "alert2"] ), *report_list ) assert_report_item_list_equal( self.mock_rep.report_item_list, report_list ) class AddRecipientTest(TestCase): def setUp(self): self.mock_log = mock.MagicMock(spec_set=logging.Logger) self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_rep = MockLibraryReportProcessor() cib = """ """ self.mock_env = LibraryEnvironment( self.mock_log, self.mock_rep, cib_data=cib ) def test_alert_not_found(self): assert_raise_library_error( lambda: cmd_alert.add_recipient( self.mock_env, "unknown", "recipient", {}, {} ), ( Severities.ERROR, report_codes.CIB_ALERT_NOT_FOUND, {"alert": "unknown"} ) ) def test_value_not_defined(self): assert_raise_library_error( lambda: cmd_alert.add_recipient( self.mock_env, "unknown", "", {}, {} ), ( Severities.ERROR, report_codes.REQUIRED_OPTION_IS_MISSING, {"option_name": "value"} ) ) def test_recipient_already_exists(self): assert_raise_library_error( lambda: cmd_alert.add_recipient( self.mock_env, "alert", "value1", {}, {}, recipient_id="alert-recipient" ), ( Severities.ERROR, report_codes.ID_ALREADY_EXISTS, {"id": "alert-recipient"} ) ) def test_without_id(self): cmd_alert.add_recipient( self.mock_env, "alert", "value", {"attr1": "val1"}, { "attr2": "val2", "attr1": "val1" } ) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) def test_with_id(self): cmd_alert.add_recipient( self.mock_env, "alert", "value", {"attr1": "val1"}, { "attr2": "val2", "attr1": "val1" }, recipient_id="my-recipient" ) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) class UpdateRecipientTest(TestCase): def setUp(self): self.mock_log = mock.MagicMock(spec_set=logging.Logger) self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_rep = MockLibraryReportProcessor() cib = """ """ self.mock_env = LibraryEnvironment( self.mock_log, self.mock_rep, cib_data=cib ) def test_empty_value(self): assert_raise_library_error( lambda: cmd_alert.update_recipient( self.mock_env, "alert-recipient-1", {}, {}, recipient_value="" ), ( Severities.ERROR, report_codes.CIB_ALERT_RECIPIENT_VALUE_INVALID, {"recipient": ""} ) ) def test_recipient_not_found(self): assert_raise_library_error( lambda: cmd_alert.update_recipient( self.mock_env, "recipient", {}, {} ), ( Severities.ERROR, report_codes.ID_NOT_FOUND, { "id": "recipient", "id_description": "Recipient" } ) ) def test_update_all(self): cmd_alert.update_recipient( self.mock_env, "alert-recipient-1", {"attr1": "value"}, { "attr1": "", "attr3": "new_val" }, recipient_value="new_val", description="desc" ) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) class RemoveRecipientTest(TestCase): def setUp(self): self.mock_log = mock.MagicMock(spec_set=logging.Logger) self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_rep = MockLibraryReportProcessor() cib = """ """ self.mock_env = LibraryEnvironment( self.mock_log, self.mock_rep, cib_data=cib ) def test_recipient_not_found(self): report_list = [ ( Severities.ERROR, report_codes.ID_NOT_FOUND, {"id": "recipient"} ), ( Severities.ERROR, report_codes.ID_NOT_FOUND, {"id": "alert2-recipient1"} ) ] assert_raise_library_error( lambda: cmd_alert.remove_recipient( self.mock_env, ["recipient", "alert-recipient1", "alert2-recipient1"] ), *report_list ) assert_report_item_list_equal( self.mock_rep.report_item_list, report_list ) def test_one_recipient(self): cmd_alert.remove_recipient(self.mock_env, ["alert-recipient1"]) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) self.assertEqual([], self.mock_rep.report_item_list) def test_multiple_recipients(self): cmd_alert.remove_recipient( self.mock_env, ["alert-recipient1", "alert-recipient2", "alert2-recipient4"] ) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) self.assertEqual([], self.mock_rep.report_item_list) def test_no_recipient(self): cmd_alert.remove_recipient(self.mock_env, []) assert_xml_equal( """ """, self.mock_env._get_cib_xml() ) self.assertEqual([], self.mock_rep.report_item_list) @mock.patch("pcs.lib.cib.alert.get_all_alerts") class GetAllAlertsTest(TestCase): def setUp(self): self.mock_log = mock.MagicMock(spec_set=logging.Logger) self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_rep = MockLibraryReportProcessor() self.mock_env = LibraryEnvironment( self.mock_log, self.mock_rep, cib_data='' ) def test_success(self, mock_alerts): mock_alerts.return_value = [{"id": "alert"}] self.assertEqual( [{"id": "alert"}], cmd_alert.get_all_alerts(self.mock_env) ) self.assertEqual(1, mock_alerts.call_count) pcs-0.9.155/pcs/lib/commands/test/test_booth.py000066400000000000000000000534331301012375000213170ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os import base64 from pcs.test.tools.pcs_unittest import TestCase from pcs.test.tools.pcs_unittest import mock from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.test.tools.assertions import ( assert_raise_library_error, assert_report_item_list_equal, ) from pcs.test.tools.misc import create_patcher from pcs import settings from pcs.common import report_codes from pcs.lib.env import LibraryEnvironment from pcs.lib.node import NodeAddresses from pcs.lib.errors import LibraryError, ReportItemSeverity as Severities from pcs.lib.commands import booth as commands from pcs.lib.external import ( NodeCommunicator, CommandRunner, EnableServiceError, DisableServiceError, StartServiceError, StopServiceError ) patch_commands = create_patcher("pcs.lib.commands.booth") @mock.patch("pcs.lib.booth.config_files.generate_key", return_value="key value") @mock.patch("pcs.lib.commands.booth.build", return_value="config content") @mock.patch("pcs.lib.booth.config_structure.validate_peers") class ConfigSetupTest(TestCase): def test_successfuly_build_and_write_to_std_path( self, mock_validate_peers, mock_build, mock_generate_key ): env = mock.MagicMock() commands.config_setup( env, booth_configuration=[ {"key": "site", "value": "1.1.1.1", "details": []}, {"key": "arbitrator", "value": "2.2.2.2", "details": []}, ], ) env.booth.create_config.assert_called_once_with( "config content", False ) env.booth.create_key.assert_called_once_with( "key value", False ) mock_validate_peers.assert_called_once_with( ["1.1.1.1"], ["2.2.2.2"] ) def test_sanitize_peers_before_validation( self, mock_validate_peers, mock_build, mock_generate_key ): commands.config_setup(env=mock.MagicMock(), booth_configuration={}) mock_validate_peers.assert_called_once_with([], []) class ConfigDestroyTest(TestCase): @patch_commands("external.is_systemctl", mock.Mock(return_value=True)) @patch_commands("external.is_service_enabled", mock.Mock(return_value=True)) @patch_commands("external.is_service_running", mock.Mock(return_value=True)) @patch_commands("resource.find_for_config", mock.Mock(return_value=[True])) def test_raises_when_booth_config_in_use(self): env = mock.MagicMock() env.booth.name = "somename" assert_raise_library_error( lambda: commands.config_destroy(env), ( Severities.ERROR, report_codes.BOOTH_CONFIG_IS_USED, { "name": "somename", "detail": "in cluster resource", } ), ( Severities.ERROR, report_codes.BOOTH_CONFIG_IS_USED, { "name": "somename", "detail": "(enabled in systemd)", } ), ( Severities.ERROR, report_codes.BOOTH_CONFIG_IS_USED, { "name": "somename", "detail": "(running in systemd)", } ) ) @patch_commands("external.is_systemctl", mock.Mock(return_value=False)) @patch_commands("resource.find_for_config", mock.Mock(return_value=[])) @patch_commands("parse", mock.Mock(side_effect=LibraryError())) def test_raises_when_cannot_get_content_of_config(self): env = mock.MagicMock() assert_raise_library_error( lambda: commands.config_destroy(env), ( Severities.ERROR, report_codes.BOOTH_CANNOT_IDENTIFY_KEYFILE, {}, report_codes.FORCE_BOOTH_DESTROY ) ) @patch_commands("external.is_systemctl", mock.Mock(return_value=False)) @patch_commands("resource.find_for_config", mock.Mock(return_value=[])) @patch_commands("parse", mock.Mock(side_effect=LibraryError())) def test_remove_config_even_if_cannot_get_its_content_when_forced(self): env = mock.MagicMock() env.report_processor = MockLibraryReportProcessor() commands.config_destroy(env, ignore_config_load_problems=True) env.booth.remove_config.assert_called_once_with() assert_report_item_list_equal(env.report_processor.report_item_list, [ ( Severities.WARNING, report_codes.BOOTH_CANNOT_IDENTIFY_KEYFILE, {} ) ]) @mock.patch("pcs.lib.commands.booth.config_structure.get_authfile") @mock.patch("pcs.lib.commands.booth.parse") @mock.patch("pcs.lib.booth.config_files.read_authfile") @mock.patch("pcs.lib.booth.sync.send_config_to_all_nodes") class ConfigSyncTest(TestCase): def setUp(self): self.mock_env = mock.MagicMock() self.mock_rep = MockLibraryReportProcessor() self.mock_env.report_processor = self.mock_rep self.mock_com = mock.MagicMock(spec_set=NodeCommunicator) self.mock_env.node_communicator.return_value = self.mock_com self.node_list = ["node1", "node2", "node3"] corosync_conf = mock.MagicMock() corosync_conf.get_nodes.return_value = self.node_list self.mock_env.get_corosync_conf.return_value = corosync_conf self.mock_env.booth.get_config_content.return_value = "config" def test_skip_offline( self, mock_sync, mock_read_key, mock_parse, mock_get_authfile ): mock_get_authfile.return_value = "/key/path.key" mock_read_key.return_value = "key" commands.config_sync(self.mock_env, "name", True) self.mock_env.booth.get_config_content.assert_called_once_with() mock_read_key.assert_called_once_with(self.mock_rep, "/key/path.key") mock_parse.assert_called_once_with("config") mock_sync.assert_called_once_with( self.mock_com, self.mock_rep, self.node_list, "name", "config", authfile="/key/path.key", authfile_data="key", skip_offline=True ) def test_do_not_skip_offline( self, mock_sync, mock_read_key, mock_parse, mock_get_authfile ): mock_get_authfile.return_value = "/key/path.key" mock_read_key.return_value = "key" commands.config_sync(self.mock_env, "name") self.mock_env.booth.get_config_content.assert_called_once_with() mock_read_key.assert_called_once_with(self.mock_rep, "/key/path.key") mock_parse.assert_called_once_with("config") mock_sync.assert_called_once_with( self.mock_com, self.mock_rep, self.node_list, "name", "config", authfile="/key/path.key", authfile_data="key", skip_offline=False ) @mock.patch("pcs.lib.commands.booth.external.ensure_is_systemd") @mock.patch("pcs.lib.external.enable_service") class EnableBoothTest(TestCase): def setUp(self): self.mock_env = mock.MagicMock(spec_set=LibraryEnvironment) self.mock_rep = MockLibraryReportProcessor() self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_env.cmd_runner.return_value = self.mock_run self.mock_env.report_processor = self.mock_rep def test_success(self, mock_enable, mock_is_systemctl): commands.enable_booth(self.mock_env, "name") mock_enable.assert_called_once_with(self.mock_run, "booth", "name") mock_is_systemctl.assert_called_once_with() assert_report_item_list_equal( self.mock_rep.report_item_list, [( Severities.INFO, report_codes.SERVICE_ENABLE_SUCCESS, { "service": "booth", "node": None, "instance": "name", } )] ) def test_failed(self, mock_enable, mock_is_systemctl): mock_enable.side_effect = EnableServiceError("booth", "msg", "name") assert_raise_library_error( lambda: commands.enable_booth(self.mock_env, "name"), ( Severities.ERROR, report_codes.SERVICE_ENABLE_ERROR, { "service": "booth", "reason": "msg", "node": None, "instance": "name", } ) ) mock_enable.assert_called_once_with(self.mock_run, "booth", "name") mock_is_systemctl.assert_called_once_with() @mock.patch("pcs.lib.commands.booth.external.ensure_is_systemd") @mock.patch("pcs.lib.external.disable_service") class DisableBoothTest(TestCase): def setUp(self): self.mock_env = mock.MagicMock(spec_set=LibraryEnvironment) self.mock_rep = MockLibraryReportProcessor() self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_env.cmd_runner.return_value = self.mock_run self.mock_env.report_processor = self.mock_rep def test_success(self, mock_disable, mock_is_systemctl): commands.disable_booth(self.mock_env, "name") mock_disable.assert_called_once_with(self.mock_run, "booth", "name") mock_is_systemctl.assert_called_once_with() assert_report_item_list_equal( self.mock_rep.report_item_list, [( Severities.INFO, report_codes.SERVICE_DISABLE_SUCCESS, { "service": "booth", "node": None, "instance": "name", } )] ) def test_failed(self, mock_disable, mock_is_systemctl): mock_disable.side_effect = DisableServiceError("booth", "msg", "name") assert_raise_library_error( lambda: commands.disable_booth(self.mock_env, "name"), ( Severities.ERROR, report_codes.SERVICE_DISABLE_ERROR, { "service": "booth", "reason": "msg", "node": None, "instance": "name", } ) ) mock_disable.assert_called_once_with(self.mock_run, "booth", "name") mock_is_systemctl.assert_called_once_with() @mock.patch("pcs.lib.commands.booth.external.ensure_is_systemd") @mock.patch("pcs.lib.external.start_service") class StartBoothTest(TestCase): def setUp(self): self.mock_env = mock.MagicMock(spec_set=LibraryEnvironment) self.mock_rep = MockLibraryReportProcessor() self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_env.cmd_runner.return_value = self.mock_run self.mock_env.report_processor = self.mock_rep def test_success(self, mock_start, mock_is_systemctl): commands.start_booth(self.mock_env, "name") mock_start.assert_called_once_with(self.mock_run, "booth", "name") mock_is_systemctl.assert_called_once_with() assert_report_item_list_equal( self.mock_rep.report_item_list, [( Severities.INFO, report_codes.SERVICE_START_SUCCESS, { "service": "booth", "node": None, "instance": "name", } )] ) def test_failed(self, mock_start, mock_is_systemctl): mock_start.side_effect = StartServiceError("booth", "msg", "name") assert_raise_library_error( lambda: commands.start_booth(self.mock_env, "name"), ( Severities.ERROR, report_codes.SERVICE_START_ERROR, { "service": "booth", "reason": "msg", "node": None, "instance": "name", } ) ) mock_start.assert_called_once_with(self.mock_run, "booth", "name") mock_is_systemctl.assert_called_once_with() @mock.patch("pcs.lib.commands.booth.external.ensure_is_systemd") @mock.patch("pcs.lib.external.stop_service") class StopBoothTest(TestCase): def setUp(self): self.mock_env = mock.MagicMock(spec_set=LibraryEnvironment) self.mock_rep = MockLibraryReportProcessor() self.mock_run = mock.MagicMock(spec_set=CommandRunner) self.mock_env.cmd_runner.return_value = self.mock_run self.mock_env.report_processor = self.mock_rep def test_success(self, mock_stop, mock_is_systemctl): commands.stop_booth(self.mock_env, "name") mock_stop.assert_called_once_with(self.mock_run, "booth", "name") mock_is_systemctl.assert_called_once_with() assert_report_item_list_equal( self.mock_rep.report_item_list, [( Severities.INFO, report_codes.SERVICE_STOP_SUCCESS, { "service": "booth", "node": None, "instance": "name", } )] ) def test_failed(self, mock_stop, mock_is_systemctl): mock_stop.side_effect = StopServiceError("booth", "msg", "name") assert_raise_library_error( lambda: commands.stop_booth(self.mock_env, "name"), ( Severities.ERROR, report_codes.SERVICE_STOP_ERROR, { "service": "booth", "reason": "msg", "node": None, "instance": "name", } ) ) mock_stop.assert_called_once_with(self.mock_run, "booth", "name") mock_is_systemctl.assert_called_once_with() @mock.patch("pcs.lib.booth.sync.pull_config_from_node") class PullConfigTest(TestCase): def setUp(self): self.mock_env = mock.MagicMock(spec_set=LibraryEnvironment) self.mock_rep = MockLibraryReportProcessor() self.mock_com = mock.MagicMock(spec_set=NodeCommunicator) self.mock_env.node_communicator.return_value = self.mock_com self.mock_env.report_processor = self.mock_rep def test_with_authfile(self, mock_pull): mock_pull.return_value = { "config": { "name": "name.conf", "data": "config" }, "authfile": { "name": "name.key", "data": base64.b64encode("key".encode("utf-8")).decode("utf-8") } } commands.pull_config(self.mock_env, "node", "name") mock_pull.assert_called_once_with( self.mock_com, NodeAddresses("node"), "name" ) self.mock_env.booth.create_config.called_once_with("config", True) self.mock_env.booth.set_key_path.called_once_with(os.path.join( settings.booth_config_dir, "name.key" )) self.mock_env.booth.create_key.called_once_with( "key".encode("utf-8"), True ) assert_report_item_list_equal( self.mock_rep.report_item_list, [ ( Severities.INFO, report_codes.BOOTH_FETCHING_CONFIG_FROM_NODE, { "node": "node", "config": "name" } ), ( Severities.INFO, report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE, { "node": None, "name_list": ["name"] } ) ] ) def test_without_authfile(self, mock_pull): mock_pull.return_value = { "config": { "name": "name.conf", "data": "config" }, "authfile": { "name": None, "data": None } } commands.pull_config(self.mock_env, "node", "name") mock_pull.assert_called_once_with( self.mock_com, NodeAddresses("node"), "name" ) self.mock_env.booth.create_config.called_once_with("config", True) self.assertEqual(0, self.mock_env.booth.set_key_path.call_count) self.assertEqual(0, self.mock_env.booth.create_key.call_count) assert_report_item_list_equal( self.mock_rep.report_item_list, [ ( Severities.INFO, report_codes.BOOTH_FETCHING_CONFIG_FROM_NODE, { "node": "node", "config": "name" } ), ( Severities.INFO, report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE, { "node": None, "name_list": ["name"] } ) ] ) def test_invalid_input(self, mock_pull): mock_pull.return_value = {} assert_raise_library_error( lambda: commands.pull_config(self.mock_env, "node", "name"), ( Severities.ERROR, report_codes.INVALID_RESPONSE_FORMAT, {"node": "node"} ) ) mock_pull.assert_called_once_with( self.mock_com, NodeAddresses("node"), "name" ) self.assertEqual(0, self.mock_env.booth.create_config.call_count) self.assertEqual(0, self.mock_env.booth.set_key_path.call_count) self.assertEqual(0, self.mock_env.booth.create_key.call_count) assert_report_item_list_equal( self.mock_rep.report_item_list, [( Severities.INFO, report_codes.BOOTH_FETCHING_CONFIG_FROM_NODE, { "node": "node", "config": "name" } )] ) class TicketOperationTest(TestCase): @mock.patch("pcs.lib.booth.resource.find_bound_ip") def test_raises_when_implicit_site_not_found_in_cib( self, mock_find_bound_ip ): mock_find_bound_ip.return_value = [] assert_raise_library_error( lambda: commands.ticket_operation( "grant", mock.Mock(), "booth", "ABC", site_ip=None ), ( Severities.ERROR, report_codes.BOOTH_CANNOT_DETERMINE_LOCAL_SITE_IP, {} ), ) def test_raises_when_command_fail(self): mock_run = mock.Mock(return_value=("some message", "error", 1)) mock_env = mock.MagicMock( cmd_runner=mock.Mock(return_value=mock.MagicMock(run=mock_run)) ) assert_raise_library_error( lambda: commands.ticket_operation( "grant", mock_env, "booth", "ABC", site_ip="1.2.3.4" ), ( Severities.ERROR, report_codes.BOOTH_TICKET_OPERATION_FAILED, { "operation": "grant", "reason": "error\nsome message", "site_ip": "1.2.3.4", "ticket_name": "ABC", } ), ) class CreateInClusterTest(TestCase): @patch_commands("get_resources", mock.MagicMock()) def test_raises_when_is_created_already(self): assert_raise_library_error( lambda: commands.create_in_cluster( mock.MagicMock(), "somename", ip="1.2.3.4", resource_create=None, resource_remove=None, ), ( Severities.ERROR, report_codes.BOOTH_ALREADY_IN_CIB, { "name": "somename", } ), ) class FindResourceElementsForOperationTest(TestCase): @patch_commands("resource.find_for_config", mock.Mock(return_value=[])) def test_raises_when_no_booth_resource_found(self): assert_raise_library_error( lambda: commands._find_resource_elements_for_operation( mock.MagicMock(), "somename", allow_multiple=False ), ( Severities.ERROR, report_codes.BOOTH_NOT_EXISTS_IN_CIB, { 'name': 'somename', } ), ) @patch_commands( "resource.find_for_config", mock.Mock(return_value=["b_el1", "b_el2"]) ) def test_raises_when_multiple_booth_resource_found(self): assert_raise_library_error( lambda: commands._find_resource_elements_for_operation( mock.MagicMock(), "somename", allow_multiple=False ), ( Severities.ERROR, report_codes.BOOTH_MULTIPLE_TIMES_IN_CIB, { 'name': 'somename', }, report_codes.FORCE_BOOTH_REMOVE_FROM_CIB, ), ) @patch_commands("get_resources", mock.Mock(return_value="resources")) @patch_commands("resource.get_remover", mock.MagicMock()) @patch_commands("resource.find_for_config", mock.Mock(return_value=[1, 2])) def test_warn_when_multiple_booth_resources_removed(self): report_processor=MockLibraryReportProcessor() commands._find_resource_elements_for_operation( mock.MagicMock(report_processor=report_processor), "somename", allow_multiple=True, ) assert_report_item_list_equal(report_processor.report_item_list, [( Severities.WARNING, report_codes.BOOTH_MULTIPLE_TIMES_IN_CIB, { 'name': 'somename', }, )]) pcs-0.9.155/pcs/lib/commands/test/test_constraint_common.py000066400000000000000000000160361301012375000237360ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from lxml import etree from pcs.common import report_codes from pcs.lib.commands.constraint import common as constraint from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import( assert_raise_library_error, assert_xml_equal, ) from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.test.tools.pcs_unittest import mock def fixture_cib_and_constraints(): cib = etree.Element("cib") resources_section = etree.SubElement(cib, "resources") for id in ("A", "B", "E", "F"): etree.SubElement(resources_section, "primitive").attrib["id"] = id constraint_section = etree.SubElement( etree.SubElement(cib, "configuration"), "constraints" ) return cib, constraint_section def fixture_env(cib): env = mock.MagicMock() env.get_cib = mock.Mock() env.get_cib.return_value = cib env.push_cib = mock.Mock() env.report_processor = MockLibraryReportProcessor() return env class CreateWithSetTest(TestCase): def setUp(self): self.cib, self.constraint_section = fixture_cib_and_constraints() self.env = fixture_env(self.cib) self.independent_cib = etree.XML(etree.tostring(self.cib)) def create(self, duplication_alowed=False): constraint.create_with_set( "rsc_some", lambda cib, options, resource_set_list: options, self.env, [ {"ids": ["A", "B"], "options": {"role": "Master"}}, {"ids": ["E", "F"], "options": {"action": "start"}}, ], {"id":"some_id", "symmetrical": "true"}, duplication_alowed=duplication_alowed ) def test_put_new_constraint_to_constraint_section(self): self.create() self.env.push_cib.assert_called_once_with(self.cib) self.independent_cib.find(".//constraints").append(etree.XML(""" """)) assert_xml_equal( etree.tostring(self.independent_cib).decode(), etree.tostring(self.cib).decode() ) def test_refuse_duplicate(self): self.create() self.env.push_cib.assert_called_once_with(self.cib) assert_raise_library_error(self.create, ( severities.ERROR, report_codes.DUPLICATE_CONSTRAINTS_EXIST, { 'constraint_type': 'rsc_some', 'constraint_info_list': [{ 'options': {'symmetrical': 'true', 'id': 'some_id'}, 'resource_sets': [ { 'ids': ['A', 'B'], 'options':{'role':'Master', 'id':'pcs_rsc_set_A_B'} }, { 'ids': ['E', 'F'], 'options':{'action':'start', 'id':'pcs_rsc_set_E_F'} } ], }] }, report_codes.FORCE_CONSTRAINT_DUPLICATE )) def test_put_duplicate_constraint_when_duplication_allowed(self): self.create() self.create(duplication_alowed=True) expected_calls = [ mock.call(self.cib), mock.call(self.cib), ] self.assertEqual(self.env.push_cib.call_count, len(expected_calls)) self.env.push_cib.assert_has_calls(expected_calls) constraint_section = self.independent_cib.find(".//constraints") constraint_section.append(etree.XML(""" """)) constraint_section.append(etree.XML(""" """)) assert_xml_equal( etree.tostring(self.independent_cib).decode(), etree.tostring(self.cib).decode() ) class ShowTest(TestCase): def setUp(self): self.cib, self.constraint_section = fixture_cib_and_constraints() self.env = fixture_env(self.cib) def create(self, tag_name, resource_set_list): constraint.create_with_set( tag_name, lambda cib, options, resource_set_list: options, self.env, resource_set_list, {"id":"some_id", "symmetrical": "true"}, ) def test_returns_export_of_found_elements(self): tag_name = "rsc_some" self.create(tag_name, [ {"ids": ["A", "B"], "options": {"role": "Master"}}, ]) self.create(tag_name, [ {"ids": ["E", "F"], "options": {"action": "start"}}, ]) etree.SubElement(self.constraint_section, tag_name).attrib.update({ "id": "plain1", "is_plain": "true" }) is_plain = lambda element: element.attrib.has_key("is_plain") self.assertEqual( constraint.show(tag_name, is_plain, self.env), { 'plain': [{"options": {'id': 'plain1', 'is_plain': 'true'}}], 'with_resource_sets': [ { 'resource_sets': [{ 'ids': ['A', 'B'], 'options': {'role': 'Master', 'id': 'pcs_rsc_set_A_B'}, }], 'options': {'symmetrical': 'true', 'id': 'some_id'} }, { 'options': {'symmetrical': 'true', 'id': 'some_id'}, 'resource_sets': [{ 'ids': ['E', 'F'], 'options': {'action': 'start', 'id': 'pcs_rsc_set_E_F'} }] } ] }) pcs-0.9.155/pcs/lib/commands/test/test_resource_agent.py000066400000000000000000000256121301012375000232070ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import logging from lxml import etree from pcs.test.tools.assertions import assert_raise_library_error from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.test.tools.pcs_unittest import mock, TestCase from pcs.common import report_codes from pcs.lib import resource_agent as lib_ra from pcs.lib.env import LibraryEnvironment from pcs.lib.errors import ReportItemSeverity as severity from pcs.lib.commands import resource_agent as lib @mock.patch("pcs.lib.resource_agent.list_resource_agents_standards") @mock.patch.object( LibraryEnvironment, "cmd_runner", lambda self: "mock_runner" ) class TestListStandards(TestCase): def setUp(self): self.mock_logger = mock.MagicMock(logging.Logger) self.mock_reporter = MockLibraryReportProcessor() self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter) def test_success(self, mock_list_standards): standards = [ "lsb", "nagios", "ocf", "service", "systemd", ] mock_list_standards.return_value = standards self.assertEqual( lib.list_standards(self.lib_env), standards ) mock_list_standards.assert_called_once_with("mock_runner") @mock.patch("pcs.lib.resource_agent.list_resource_agents_ocf_providers") @mock.patch.object( LibraryEnvironment, "cmd_runner", lambda self: "mock_runner" ) class TestListOcfProviders(TestCase): def setUp(self): self.mock_logger = mock.MagicMock(logging.Logger) self.mock_reporter = MockLibraryReportProcessor() self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter) def test_success(self, mock_list_providers): providers = [ "booth", "heartbeat", "openstack", "pacemaker", ] mock_list_providers.return_value = providers self.assertEqual( lib.list_ocf_providers(self.lib_env), providers ) mock_list_providers.assert_called_once_with("mock_runner") @mock.patch("pcs.lib.resource_agent.list_resource_agents_standards") @mock.patch("pcs.lib.resource_agent.list_resource_agents") @mock.patch.object( LibraryEnvironment, "cmd_runner", lambda self: "mock_runner" ) class TestListAgentsForStandardAndProvider(TestCase): def setUp(self): self.mock_logger = mock.MagicMock(logging.Logger) self.mock_reporter = MockLibraryReportProcessor() self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter) def test_standard_specified(self, mock_list_agents, mock_list_standards): agents = [ "Delay", "Dummy", "Stateful", ] mock_list_agents.return_value = agents self.assertEqual( lib.list_agents_for_standard_and_provider(self.lib_env, "ocf:test"), agents ) mock_list_agents.assert_called_once_with("mock_runner", "ocf:test") mock_list_standards.assert_not_called() def test_standard_not_specified( self, mock_list_agents, mock_list_standards ): agents_ocf = [ "Delay", "Dummy", "Stateful", ] agents_service = [ "corosync", "pacemaker", "pcsd", ] mock_list_standards.return_value = ["ocf:test", "service"] mock_list_agents.side_effect = [agents_ocf, agents_service] self.assertEqual( lib.list_agents_for_standard_and_provider(self.lib_env), sorted(agents_ocf + agents_service, key=lambda x: x.lower()) ) mock_list_standards.assert_called_once_with("mock_runner") self.assertEqual(2, len(mock_list_agents.mock_calls)) mock_list_agents.assert_has_calls([ mock.call("mock_runner", "ocf:test"), mock.call("mock_runner", "service"), ]) @mock.patch( "pcs.lib.resource_agent.list_resource_agents_standards_and_providers", lambda runner: ["service", "ocf:test"] ) @mock.patch( "pcs.lib.resource_agent.list_resource_agents", lambda runner, standard: { "ocf:test": [ "Stateful", "Delay", ], "service": [ "corosync", "pacemaker_remote", ], }.get(standard, []) ) @mock.patch.object( LibraryEnvironment, "cmd_runner", lambda self: "mock_runner" ) class TestListAgents(TestCase): def setUp(self): self.mock_logger = mock.MagicMock(logging.Logger) self.mock_reporter = MockLibraryReportProcessor() self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter) def test_list_all(self): self.assertEqual( lib.list_agents(self.lib_env, False, None), [ { "name": "ocf:test:Delay", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, { "name": "ocf:test:Stateful", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, { "name": "service:corosync", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, { "name": "service:pacemaker_remote", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, ] ) def test_search(self): self.assertEqual( lib.list_agents(self.lib_env, False, "te"), [ { "name": "ocf:test:Delay", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, { "name": "ocf:test:Stateful", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, { "name": "service:pacemaker_remote", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, ] ) @mock.patch.object(lib_ra.Agent, "_get_metadata", autospec=True) def test_describe(self, mock_metadata): def mock_metadata_func(self): if self._full_agent_name == "ocf:test:Stateful": raise lib_ra.UnableToGetAgentMetadata( self._full_agent_name, "test exception" ) return etree.XML(""" short {name} long {name} """.format(name=self._full_agent_name)) mock_metadata.side_effect = mock_metadata_func # Stateful is missing as it does not provide valid metadata - see above self.assertEqual( lib.list_agents(self.lib_env, True, None), [ { "name": "ocf:test:Delay", "shortdesc": "short ocf:test:Delay", "longdesc": "long ocf:test:Delay", "parameters": [], "actions": [], }, { "name": "service:corosync", "shortdesc": "short service:corosync", "longdesc": "long service:corosync", "parameters": [], "actions": [], }, { "name": "service:pacemaker_remote", "shortdesc": "short service:pacemaker_remote", "longdesc": "long service:pacemaker_remote", "parameters": [], "actions": [], }, ] ) @mock.patch.object(lib_ra.ResourceAgent, "_load_metadata", autospec=True) @mock.patch("pcs.lib.resource_agent.guess_exactly_one_resource_agent_full_name") @mock.patch.object( LibraryEnvironment, "cmd_runner", lambda self: "mock_runner" ) class TestDescribeAgent(TestCase): def setUp(self): self.mock_logger = mock.MagicMock(logging.Logger) self.mock_reporter = MockLibraryReportProcessor() self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter) self.metadata = """ short desc long desc """ self.description = { "name": "ocf:test:Dummy", "shortdesc": "short desc", "longdesc": "long desc", "parameters": [], "actions": [], } def test_full_name_success(self, mock_guess, mock_metadata): mock_metadata.return_value = self.metadata self.assertEqual( lib.describe_agent(self.lib_env, "ocf:test:Dummy"), self.description ) self.assertEqual(len(mock_metadata.mock_calls), 1) mock_guess.assert_not_called() def test_guess_success(self, mock_guess, mock_metadata): mock_metadata.return_value = self.metadata mock_guess.return_value = lib_ra.ResourceAgent( self.lib_env.cmd_runner(), "ocf:test:Dummy" ) self.assertEqual( lib.describe_agent(self.lib_env, "dummy"), self.description ) self.assertEqual(len(mock_metadata.mock_calls), 1) mock_guess.assert_called_once_with("mock_runner", "dummy") def test_full_name_fail(self, mock_guess, mock_metadata): mock_metadata.return_value = "invalid xml" assert_raise_library_error( lambda: lib.describe_agent(self.lib_env, "ocf:test:Dummy"), ( severity.ERROR, report_codes.UNABLE_TO_GET_AGENT_METADATA, { "agent": "ocf:test:Dummy", "reason": "Start tag expected, '<' not found, line 1, column 1", } ) ) self.assertEqual(len(mock_metadata.mock_calls), 1) mock_guess.assert_not_called() pcs-0.9.155/pcs/lib/commands/test/test_stonith_agent.py000066400000000000000000000143041301012375000230440ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import logging from lxml import etree from pcs.test.tools.assertions import assert_raise_library_error from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.test.tools.pcs_unittest import mock, TestCase from pcs.common import report_codes from pcs.lib import resource_agent as lib_ra from pcs.lib.env import LibraryEnvironment from pcs.lib.errors import ReportItemSeverity as severity from pcs.lib.commands import stonith_agent as lib @mock.patch( "pcs.lib.resource_agent.list_stonith_agents", lambda runner: [ "fence_apc", "fence_dummy", "fence_xvm", ] ) @mock.patch.object( LibraryEnvironment, "cmd_runner", lambda self: "mock_runner" ) class TestListAgents(TestCase): def setUp(self): self.mock_logger = mock.MagicMock(logging.Logger) self.mock_reporter = MockLibraryReportProcessor() self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter) def tearDown(self): lib_ra.StonithAgent._stonithd_metadata = None def test_list_all(self): self.assertEqual( lib.list_agents(self.lib_env, False, None), [ { "name": "fence_apc", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, { "name": "fence_dummy", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, { "name": "fence_xvm", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, ] ) def test_search(self): self.assertEqual( lib.list_agents(self.lib_env, False, "M"), [ { "name": "fence_dummy", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, { "name": "fence_xvm", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], }, ] ) @mock.patch.object(lib_ra.Agent, "_get_metadata", autospec=True) def test_describe(self, mock_metadata): def mock_metadata_func(self): if self._full_agent_name == "ocf:test:Stateful": raise lib_ra.UnableToGetAgentMetadata( self._full_agent_name, "test exception" ) return etree.XML(""" short {name} long {name} """.format(name=self._full_agent_name)) mock_metadata.side_effect = mock_metadata_func # Stateful is missing as it does not provide valid metadata - see above self.assertEqual( lib.list_agents(self.lib_env, True, None), [ { "name": "fence_apc", "shortdesc": "short stonith:fence_apc", "longdesc": "long stonith:fence_apc", "parameters": [], "actions": [], }, { "name": "fence_dummy", "shortdesc": "short stonith:fence_dummy", "longdesc": "long stonith:fence_dummy", "parameters": [], "actions": [], }, { "name": "fence_xvm", "shortdesc": "short stonith:fence_xvm", "longdesc": "long stonith:fence_xvm", "parameters": [], "actions": [], }, ] ) @mock.patch.object(lib_ra.StonithAgent, "_load_metadata", autospec=True) @mock.patch.object( lib_ra.StonithdMetadata, "get_parameters", lambda self: [] ) @mock.patch.object( LibraryEnvironment, "cmd_runner", lambda self: "mock_runner" ) class TestDescribeAgent(TestCase): def setUp(self): self.mock_logger = mock.MagicMock(logging.Logger) self.mock_reporter = MockLibraryReportProcessor() self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter) self.metadata = """ short desc long desc """ self.description = { "name": "fence_dummy", "shortdesc": "short desc", "longdesc": "long desc", "parameters": [], "actions": [], } def tearDown(self): lib_ra.StonithAgent._stonithd_metadata = None def test_success(self, mock_metadata): mock_metadata.return_value = self.metadata self.assertEqual( lib.describe_agent(self.lib_env, "fence_dummy"), self.description ) self.assertEqual(len(mock_metadata.mock_calls), 1) def test_fail(self, mock_metadata): mock_metadata.return_value = "invalid xml" assert_raise_library_error( lambda: lib.describe_agent(self.lib_env, "fence_dummy"), ( severity.ERROR, report_codes.UNABLE_TO_GET_AGENT_METADATA, { "agent": "fence_dummy", "reason": "Start tag expected, '<' not found, line 1, column 1", } ) ) self.assertEqual(len(mock_metadata.mock_calls), 1) pcs-0.9.155/pcs/lib/commands/test/test_ticket.py000066400000000000000000000061771301012375000214720ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.test.tools.pcs_unittest import mock from pcs.test.tools.misc import create_patcher from pcs.common import report_codes from pcs.lib.commands.constraint import ticket as ticket_command from pcs.lib.errors import ReportItemSeverity as severities from pcs.lib.test.misc import get_mocked_env from pcs.test.tools.assertions import ( assert_xml_equal, assert_raise_library_error ) from pcs.test.tools.misc import get_test_resource as rc from pcs.test.tools.xml import get_xml_manipulation_creator_from_file patch_commands = create_patcher("pcs.lib.commands.constraint.ticket") class CreateTest(TestCase): def setUp(self): self.create_cib = get_xml_manipulation_creator_from_file( rc("cib-empty.xml") ) def test_sucess_create(self): resource_xml = '' cib = ( self.create_cib() .append_to_first_tag_name('resources', resource_xml) ) env = get_mocked_env(cib_data=str(cib)) ticket_command.create(env, "ticketA", "resourceA", { "loss-policy": "fence", "rsc-role": "master" }) assert_xml_equal( env._get_cib_xml(), str(cib.append_to_first_tag_name( 'constraints', """ """ )) ) def test_refuse_for_nonexisting_resource(self): env = get_mocked_env(cib_data=str(self.create_cib())) assert_raise_library_error( lambda: ticket_command.create( env, "ticketA", "resourceA", "master", {"loss-policy": "fence"} ), ( severities.ERROR, report_codes.RESOURCE_DOES_NOT_EXIST, {"resource_id": "resourceA"}, ), ) @patch_commands("get_constraints", mock.Mock) class RemoveTest(TestCase): @patch_commands("ticket.remove_plain", mock.Mock(return_value=1)) @patch_commands("ticket.remove_with_resource_set",mock.Mock(return_value=0)) def test_successfully_remove_plain(self): self.assertTrue(ticket_command.remove(mock.MagicMock(), "T", "R")) @patch_commands("ticket.remove_plain", mock.Mock(return_value=0)) @patch_commands("ticket.remove_with_resource_set",mock.Mock(return_value=1)) def test_successfully_remove_with_resource_set(self): self.assertTrue(ticket_command.remove(mock.MagicMock(), "T", "R")) @patch_commands("ticket.remove_plain", mock.Mock(return_value=0)) @patch_commands("ticket.remove_with_resource_set",mock.Mock(return_value=0)) def test_raises_library_error_when_no_matching_constraint_found(self): self.assertFalse(ticket_command.remove(mock.MagicMock(), "T", "R")) pcs-0.9.155/pcs/lib/corosync/000077500000000000000000000000001301012375000156425ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/corosync/__init__.py000066400000000000000000000000001301012375000177410ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/corosync/config_facade.py000066400000000000000000000502401301012375000207450ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.common import report_codes from pcs.lib import reports from pcs.lib.errors import ReportItemSeverity, LibraryError from pcs.lib.corosync import config_parser from pcs.lib.node import NodeAddresses, NodeAddressesList class ConfigFacade(object): """ Provides high level access to a corosync config file """ QUORUM_OPTIONS = ( "auto_tie_breaker", "last_man_standing", "last_man_standing_window", "wait_for_all", ) QUORUM_OPTIONS_INCOMPATIBLE_WITH_QDEVICE = ( "auto_tie_breaker", "last_man_standing", "last_man_standing_window", ) @classmethod def from_string(cls, config_string): """ Parse corosync config and create a facade around it config_string corosync config text """ try: return cls(config_parser.parse_string(config_string)) except config_parser.MissingClosingBraceException: raise LibraryError( reports.corosync_config_parser_missing_closing_brace() ) except config_parser.UnexpectedClosingBraceException: raise LibraryError( reports.corosync_config_parser_unexpected_closing_brace() ) except config_parser.CorosyncConfParserException: raise LibraryError( reports.corosync_config_parser_other_error() ) def __init__(self, parsed_config): """ Create a facade around a parsed corosync config file parsed_config parsed corosync config """ self._config = parsed_config # set to True if changes cannot be applied on running cluster self._need_stopped_cluster = False # set to True if qdevice reload is required to apply changes self._need_qdevice_reload = False @property def config(self): return self._config @property def need_stopped_cluster(self): return self._need_stopped_cluster @property def need_qdevice_reload(self): return self._need_qdevice_reload def get_cluster_name(self): cluster_name = "" for totem in self.config.get_sections("totem"): for attrs in totem.get_attributes("cluster_name"): cluster_name = attrs[1] return cluster_name def get_nodes(self): """ Get all defined nodes """ result = NodeAddressesList() for nodelist in self.config.get_sections("nodelist"): for node in nodelist.get_sections("node"): node_data = { "ring0_addr": None, "ring1_addr": None, "name": None, "nodeid": None, } for attr_name, attr_value in node.get_attributes(): if attr_name in node_data: node_data[attr_name] = attr_value result.append(NodeAddresses( node_data["ring0_addr"], node_data["ring1_addr"], node_data["name"], node_data["nodeid"] )) return result def set_quorum_options(self, report_processor, options): """ Set options in quorum section options quorum options dict """ report_processor.process_list( self.__validate_quorum_options(options) ) quorum_section_list = self.__ensure_section(self.config, "quorum") self.__set_section_options(quorum_section_list, options) self.__update_two_node() self.__remove_empty_sections(self.config) self._need_stopped_cluster = True def get_quorum_options(self): """ Get configurable options from quorum section """ options = {} for section in self.config.get_sections("quorum"): for name, value in section.get_attributes(): if name in self.__class__.QUORUM_OPTIONS: options[name] = value return options def is_enabled_auto_tie_breaker(self): """ Returns True if auto tie braker option is enabled, False otherwise. """ auto_tie_breaker = "0" for quorum in self.config.get_sections("quorum"): for attr in quorum.get_attributes("auto_tie_breaker"): auto_tie_breaker = attr[1] return auto_tie_breaker == "1" def __validate_quorum_options(self, options): report_items = [] has_qdevice = self.has_quorum_device() qdevice_incompatible_options = [] for name, value in sorted(options.items()): allowed_names = self.__class__.QUORUM_OPTIONS if name not in allowed_names: report_items.append( reports.invalid_option(name, allowed_names, "quorum") ) continue if value == "": continue if ( has_qdevice and name in self.__class__.QUORUM_OPTIONS_INCOMPATIBLE_WITH_QDEVICE ): qdevice_incompatible_options.append(name) if name == "last_man_standing_window": if not value.isdigit(): report_items.append(reports.invalid_option_value( name, value, "positive integer" )) else: allowed_values = ("0", "1") if value not in allowed_values: report_items.append(reports.invalid_option_value( name, value, allowed_values )) if qdevice_incompatible_options: report_items.append( reports.corosync_options_incompatible_with_qdevice( qdevice_incompatible_options ) ) return report_items def has_quorum_device(self): """ Check if quorum device is present in the config """ for quorum in self.config.get_sections("quorum"): for device in quorum.get_sections("device"): if device.get_attributes("model"): return True return False def get_quorum_device_settings(self): """ Get configurable options from quorum.device section """ model = None model_options = {} generic_options = {} for quorum in self.config.get_sections("quorum"): for device in quorum.get_sections("device"): for name, value in device.get_attributes(): if name == "model": model = value else: generic_options[name] = value for subsection in device.get_sections(): if subsection.name not in model_options: model_options[subsection.name] = {} model_options[subsection.name].update( subsection.get_attributes() ) return model, model_options.get(model, {}), generic_options def add_quorum_device( self, report_processor, model, model_options, generic_options, force_model=False, force_options=False, ): """ Add quorum device configuration model quorum device model model_options model specific options dict generic_options generic quorum device options dict force_model continue even if the model is not valid force_options continue even if options are not valid """ # validation if self.has_quorum_device(): raise LibraryError(reports.qdevice_already_defined()) report_processor.process_list( self.__validate_quorum_device_model(model, force_model) + self.__validate_quorum_device_model_options( model, model_options, need_required=True, force=force_options ) + self.__validate_quorum_device_generic_options( generic_options, force=force_options ) ) # configuration cleanup remove_need_stopped_cluster = dict([ (name, "") for name in self.__class__.QUORUM_OPTIONS_INCOMPATIBLE_WITH_QDEVICE ]) # remove old device settings quorum_section_list = self.__ensure_section(self.config, "quorum") for quorum in quorum_section_list: for device in quorum.get_sections("device"): quorum.del_section(device) for name, value in quorum.get_attributes(): if ( name in remove_need_stopped_cluster and value not in ["", "0"] ): self._need_stopped_cluster = True # remove conflicting quorum options attrs_to_remove = { "allow_downscale": "", "two_node": "", } attrs_to_remove.update(remove_need_stopped_cluster) self.__set_section_options(quorum_section_list, attrs_to_remove) # remove nodes' votes for nodelist in self.config.get_sections("nodelist"): for node in nodelist.get_sections("node"): node.del_attributes_by_name("quorum_votes") # add new configuration quorum = quorum_section_list[-1] new_device = config_parser.Section("device") quorum.add_section(new_device) self.__set_section_options([new_device], generic_options) new_device.set_attribute("model", model) new_model = config_parser.Section(model) self.__set_section_options([new_model], model_options) new_device.add_section(new_model) self.__update_qdevice_votes() self.__update_two_node() self.__remove_empty_sections(self.config) def update_quorum_device( self, report_processor, model_options, generic_options, force_options=False ): """ Update existing quorum device configuration model_options model specific options dict generic_options generic quorum device options dict force_options continue even if options are not valid """ # validation if not self.has_quorum_device(): raise LibraryError(reports.qdevice_not_defined()) model = None for quorum in self.config.get_sections("quorum"): for device in quorum.get_sections("device"): for dummy_name, value in device.get_attributes("model"): model = value report_processor.process_list( self.__validate_quorum_device_model_options( model, model_options, need_required=False, force=force_options ) + self.__validate_quorum_device_generic_options( generic_options, force=force_options ) ) # set new configuration device_sections = [] model_sections = [] for quorum in self.config.get_sections("quorum"): device_sections.extend(quorum.get_sections("device")) for device in quorum.get_sections("device"): model_sections.extend(device.get_sections(model)) self.__set_section_options(device_sections, generic_options) self.__set_section_options(model_sections, model_options) self.__update_qdevice_votes() self.__update_two_node() self.__remove_empty_sections(self.config) self._need_qdevice_reload = True def remove_quorum_device(self): """ Remove all quorum device configuration """ if not self.has_quorum_device(): raise LibraryError(reports.qdevice_not_defined()) for quorum in self.config.get_sections("quorum"): for device in quorum.get_sections("device"): quorum.del_section(device) self.__update_two_node() self.__remove_empty_sections(self.config) def __validate_quorum_device_model(self, model, force_model=False): report_items = [] allowed_values = ( "net", ) if model not in allowed_values: report_items.append(reports.invalid_option_value( "model", model, allowed_values, ReportItemSeverity.WARNING if force_model else ReportItemSeverity.ERROR, None if force_model else report_codes.FORCE_QDEVICE_MODEL )) return report_items def __validate_quorum_device_model_options( self, model, model_options, need_required, force=False ): if model == "net": return self.__validate_quorum_device_model_net_options( model_options, need_required, force ) return [] def __validate_quorum_device_model_net_options( self, model_options, need_required, force=False ): required_options = frozenset(["host", "algorithm"]) optional_options = frozenset([ "connect_timeout", "force_ip_version", "port", "tie_breaker", ]) allowed_options = required_options | optional_options model_options_names = frozenset(model_options.keys()) report_items = [] severity = ( ReportItemSeverity.WARNING if force else ReportItemSeverity.ERROR ) forceable = None if force else report_codes.FORCE_OPTIONS if need_required: for missing in sorted(required_options - model_options_names): report_items.append(reports.required_option_is_missing(missing)) for name, value in sorted(model_options.items()): if name not in allowed_options: report_items.append(reports.invalid_option( name, allowed_options, "quorum device model", severity, forceable )) continue if value == "": # do not allow to remove required options if name in required_options: report_items.append( reports.required_option_is_missing(name) ) else: continue if name == "algorithm": allowed_values = ("ffsplit", "lms") if value not in allowed_values: report_items.append(reports.invalid_option_value( name, value, allowed_values, severity, forceable )) if name == "connect_timeout": minimum, maximum = 1000, 2*60*1000 if not (value.isdigit() and minimum <= int(value) <= maximum): min_max = "{min}-{max}".format(min=minimum, max=maximum) report_items.append(reports.invalid_option_value( name, value, min_max, severity, forceable )) if name == "force_ip_version": allowed_values = ("0", "4", "6") if value not in allowed_values: report_items.append(reports.invalid_option_value( name, value, allowed_values, severity, forceable )) if name == "port": minimum, maximum = 1, 65535 if not (value.isdigit() and minimum <= int(value) <= maximum): min_max = "{min}-{max}".format(min=minimum, max=maximum) report_items.append(reports.invalid_option_value( name, value, min_max, severity, forceable )) if name == "tie_breaker": node_ids = [node.id for node in self.get_nodes()] allowed_nonid = ["lowest", "highest"] if value not in allowed_nonid + node_ids: allowed_values = allowed_nonid + ["valid node id"] report_items.append(reports.invalid_option_value( name, value, allowed_values, severity, forceable )) return report_items def __validate_quorum_device_generic_options( self, generic_options, force=False ): optional_options = frozenset([ "sync_timeout", "timeout", ]) allowed_options = optional_options report_items = [] severity = ( ReportItemSeverity.WARNING if force else ReportItemSeverity.ERROR ) forceable = None if force else report_codes.FORCE_OPTIONS for name, value in sorted(generic_options.items()): if name not in allowed_options: # model is never allowed in generic options, it is passed # in its own argument report_items.append(reports.invalid_option( name, allowed_options, "quorum device", severity if name != "model" else ReportItemSeverity.ERROR, forceable if name != "model" else None )) continue if value == "": continue if not value.isdigit(): report_items.append(reports.invalid_option_value( name, value, "positive integer", severity, forceable )) return report_items def __update_two_node(self): # get relevant status has_quorum_device = self.has_quorum_device() has_two_nodes = len(self.get_nodes()) == 2 auto_tie_breaker = self.is_enabled_auto_tie_breaker() # update two_node if has_two_nodes and not auto_tie_breaker and not has_quorum_device: quorum_section_list = self.__ensure_section(self.config, "quorum") self.__set_section_options(quorum_section_list, {"two_node": "1"}) else: for quorum in self.config.get_sections("quorum"): quorum.del_attributes_by_name("two_node") def __update_qdevice_votes(self): # ffsplit won't start if votes is missing or not set to 1 # for other algorithms it's required not to put votes at all model = None algorithm = None device_sections = [] for quorum in self.config.get_sections("quorum"): for device in quorum.get_sections("device"): device_sections.append(device) for dummy_name, value in device.get_attributes("model"): model = value for device in device_sections: for model_section in device.get_sections(model): for dummy_name, value in model_section.get_attributes( "algorithm" ): algorithm = value if model == "net": if algorithm == "ffsplit": self.__set_section_options(device_sections, {"votes": "1"}) else: self.__set_section_options(device_sections, {"votes": ""}) def __set_section_options(self, section_list, options): for section in section_list[:-1]: for name in options: section.del_attributes_by_name(name) for name, value in sorted(options.items()): if value == "": section_list[-1].del_attributes_by_name(name) else: section_list[-1].set_attribute(name, value) def __ensure_section(self, parent_section, section_name): section_list = parent_section.get_sections(section_name) if not section_list: new_section = config_parser.Section(section_name) parent_section.add_section(new_section) section_list.append(new_section) return section_list def __remove_empty_sections(self, parent_section): for section in parent_section.get_sections(): self.__remove_empty_sections(section) if section.empty: parent_section.del_section(section) pcs-0.9.155/pcs/lib/corosync/config_parser.py000066400000000000000000000111571301012375000210420ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) class Section(object): def __init__(self, name): self._parent = None self._attr_list = [] self._section_list = [] self._name = name @property def parent(self): return self._parent @property def name(self): return self._name @property def empty(self): return not self._attr_list and not self._section_list def export(self, indent=" "): lines = [] for attr in self._attr_list: lines.append("{0}: {1}".format(*attr)) if self._attr_list and self._section_list: lines.append("") section_count = len(self._section_list) for index, section in enumerate(self._section_list, 1): lines.extend(str(section).split("\n")) if not lines[-1].strip(): del lines[-1] if index < section_count: lines.append("") if self.parent: lines = [indent + x if x else x for x in lines] lines.insert(0, self.name + " {") lines.append("}") final = "\n".join(lines) if final: final += "\n" return final def get_root(self): parent = self while parent.parent: parent = parent.parent return parent def get_attributes(self, name=None): return [ attr for attr in self._attr_list if name is None or attr[0] == name ] def add_attribute(self, name, value): self._attr_list.append([name, value]) return self def del_attribute(self, attribute): self._attr_list = [ attr for attr in self._attr_list if attr != attribute ] return self def del_attributes_by_name(self, name, value=None): self._attr_list = [ attr for attr in self._attr_list if not(attr[0] == name and (value is None or attr[1] == value)) ] return self def set_attribute(self, name, value): found = False new_attr_list = [] for attr in self._attr_list: if attr[0] != name: new_attr_list.append(attr) elif not found: found = True attr[1] = value new_attr_list.append(attr) self._attr_list = new_attr_list if not found: self.add_attribute(name, value) return self def get_sections(self, name=None): return [ section for section in self._section_list if name is None or section.name == name ] def add_section(self, section): parent = self while parent: if parent == section: raise CircularParentshipException() parent = parent.parent if section.parent: section.parent.del_section(section) section._parent = self self._section_list.append(section) return self def del_section(self, section): self._section_list.remove(section) # don't set parent to None if the section was not found in the list # thanks to remove raising a ValueError in that case section._parent = None return self def __str__(self): return self.export() def parse_string(conf_text): root = Section("") _parse_section(conf_text.split("\n"), root) return root def _parse_section(lines, section): # parser is trying to work the same way as an original corosync parser while lines: current_line = lines.pop(0).strip() if not current_line or current_line[0] == "#": continue if "{" in current_line: section_name, dummy_junk = current_line.rsplit("{", 1) new_section = Section(section_name.strip()) section.add_section(new_section) _parse_section(lines, new_section) elif "}" in current_line: if not section.parent: raise UnexpectedClosingBraceException() return elif ":" in current_line: section.add_attribute( *[x.strip() for x in current_line.split(":", 1)] ) if section.parent: raise MissingClosingBraceException() class CorosyncConfParserException(Exception): pass class CircularParentshipException(CorosyncConfParserException): pass class ParseErrorException(CorosyncConfParserException): pass class MissingClosingBraceException(ParseErrorException): pass class UnexpectedClosingBraceException(ParseErrorException): pass pcs-0.9.155/pcs/lib/corosync/live.py000066400000000000000000000052571301012375000171640ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os.path from pcs import settings from pcs.common.tools import join_multilines from pcs.lib import reports from pcs.lib.errors import LibraryError from pcs.lib.external import NodeCommunicator def get_local_corosync_conf(): """ Read corosync.conf file from local machine """ path = settings.corosync_conf_file try: return open(path).read() except EnvironmentError as e: raise LibraryError(reports.corosync_config_read_error(path, e.strerror)) def get_local_cluster_conf(): """ Read cluster.conf file from local machine """ path = settings.cluster_conf_file try: return open(path).read() except EnvironmentError as e: raise LibraryError(reports.cluster_conf_read_error(path, e.strerror)) def exists_local_corosync_conf(): return os.path.exists(settings.corosync_conf_file) def set_remote_corosync_conf(node_communicator, node_addr, config_text): """ Send corosync.conf to a node node_addr instance of NodeAddresses config_text corosync.conf text """ dummy_response = node_communicator.call_node( node_addr, "remote/set_corosync_conf", NodeCommunicator.format_data_dict({'corosync_conf': config_text}) ) def reload_config(runner): """ Ask corosync to reload its configuration """ stdout, stderr, retval = runner.run([ os.path.join(settings.corosync_binaries, "corosync-cfgtool"), "-R" ]) message = join_multilines([stderr, stdout]) if retval != 0 or "invalid option" in message: raise LibraryError(reports.corosync_config_reload_error(message)) def get_quorum_status_text(runner): """ Get runtime quorum status from the local node """ stdout, stderr, retval = runner.run([ os.path.join(settings.corosync_binaries, "corosync-quorumtool"), "-p" ]) # retval is 0 on success if node is not in partition with quorum # retval is 1 on error OR on success if node has quorum if retval not in [0, 1] or stderr.strip(): raise LibraryError(reports.corosync_quorum_get_status_error(stderr)) return stdout def set_expected_votes(runner, votes): """ set expected votes in live cluster to specified value """ stdout, stderr, retval = runner.run([ os.path.join(settings.corosync_binaries, "corosync-quorumtool"), # format votes to handle the case where they are int "-e", "{0}".format(votes) ]) if retval != 0: raise LibraryError( reports.corosync_quorum_set_expected_votes_error(stderr) ) return stdout pcs-0.9.155/pcs/lib/corosync/qdevice_client.py000066400000000000000000000052501301012375000211740ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os.path from pcs import settings from pcs.common.tools import join_multilines from pcs.lib import reports from pcs.lib.errors import LibraryError def get_status_text(runner, verbose=False): """ Get quorum device client runtime status in plain text bool verbose get more detailed output """ cmd = [ os.path.join(settings.corosync_binaries, "corosync-qdevice-tool"), "-s" ] if verbose: cmd.append("-v") stdout, stderr, retval = runner.run(cmd) if retval != 0: raise LibraryError( reports.corosync_quorum_get_status_error( join_multilines([stderr, stdout]) ) ) return stdout def remote_client_enable(reporter, node_communicator, node): """ enable qdevice client service (corosync-qdevice) on a remote node """ response = node_communicator.call_node( node, "remote/qdevice_client_enable", None ) if response == "corosync is not enabled, skipping": reporter.process( reports.service_enable_skipped( "corosync-qdevice", "corosync is not enabled", node.label ) ) else: reporter.process( reports.service_enable_success("corosync-qdevice", node.label) ) def remote_client_disable(reporter, node_communicator, node): """ disable qdevice client service (corosync-qdevice) on a remote node """ node_communicator.call_node(node, "remote/qdevice_client_disable", None) reporter.process( reports.service_disable_success("corosync-qdevice", node.label) ) def remote_client_start(reporter, node_communicator, node): """ start qdevice client service (corosync-qdevice) on a remote node """ response = node_communicator.call_node( node, "remote/qdevice_client_start", None ) if response == "corosync is not running, skipping": reporter.process( reports.service_start_skipped( "corosync-qdevice", "corosync is not running", node.label ) ) else: reporter.process( reports.service_start_success("corosync-qdevice", node.label) ) def remote_client_stop(reporter, node_communicator, node): """ stop qdevice client service (corosync-qdevice) on a remote node """ node_communicator.call_node(node, "remote/qdevice_client_stop", None) reporter.process( reports.service_stop_success("corosync-qdevice", node.label) ) pcs-0.9.155/pcs/lib/corosync/qdevice_net.py000066400000000000000000000320721301012375000205060ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import base64 import binascii import functools import os import os.path import re import shutil import tempfile from pcs import settings from pcs.common.tools import join_multilines from pcs.lib import external, reports from pcs.lib.errors import LibraryError __model = "net" __service_name = "corosync-qnetd" __qnetd_certutil = os.path.join( settings.corosync_qnet_binaries, "corosync-qnetd-certutil" ) __qnetd_tool = os.path.join( settings.corosync_qnet_binaries, "corosync-qnetd-tool" ) __qdevice_certutil = os.path.join( settings.corosync_binaries, "corosync-qdevice-net-certutil" ) class QnetdNotRunningException(Exception): pass def qdevice_setup(runner): """ initialize qdevice on local host """ if external.is_dir_nonempty(settings.corosync_qdevice_net_server_certs_dir): raise LibraryError(reports.qdevice_already_initialized(__model)) stdout, stderr, retval = runner.run([ __qnetd_certutil, "-i" ]) if retval != 0: raise LibraryError( reports.qdevice_initialization_error( __model, join_multilines([stderr, stdout]) ) ) def qdevice_initialized(): """ check if qdevice server certificate database has been initialized """ return os.path.exists(os.path.join( settings.corosync_qdevice_net_server_certs_dir, "cert8.db" )) def qdevice_destroy(): """ delete qdevice configuration on local host """ try: if qdevice_initialized(): shutil.rmtree(settings.corosync_qdevice_net_server_certs_dir) except EnvironmentError as e: raise LibraryError( reports.qdevice_destroy_error(__model, e.strerror) ) def qdevice_status_generic_text(runner, verbose=False): """ get qdevice runtime status in plain text bool verbose get more detailed output """ args = ["-s"] if verbose: args.append("-v") stdout, stderr, retval = _qdevice_run_tool(runner, args) if retval != 0: raise LibraryError( reports.qdevice_get_status_error( __model, join_multilines([stderr, stdout]) ) ) return stdout def qdevice_status_cluster_text(runner, cluster=None, verbose=False): """ get qdevice runtime status in plain text bool verbose get more detailed output string cluster show information only about specified cluster """ args = ["-l"] if verbose: args.append("-v") if cluster: args.extend(["-c", cluster]) stdout, stderr, retval = _qdevice_run_tool(runner, args) if retval != 0: raise LibraryError( reports.qdevice_get_status_error( __model, join_multilines([stderr, stdout]) ) ) return stdout def qdevice_connected_clusters(status_cluster_text): """ parse qnetd cluster status listing and return connected clusters' names string status_cluster_text output of corosync-qnetd-tool -l """ connected_clusters = [] regexp = re.compile(r'^Cluster "(?P[^"]+)":$') for line in status_cluster_text.splitlines(): match = regexp.search(line) if match: connected_clusters.append(match.group("cluster")) return connected_clusters def _qdevice_run_tool(runner, args): """ run corosync-qnetd-tool, raise QnetdNotRunningException if qnetd not running CommandRunner runner iterable args corosync-qnetd-tool arguments """ stdout, stderr, retval = runner.run([__qnetd_tool] + args) if retval == 3 and "is qnetd running?" in stderr.lower(): raise QnetdNotRunningException() return stdout, stderr, retval def qdevice_enable(runner): """ make qdevice start automatically on boot on local host """ external.enable_service(runner, __service_name) def qdevice_disable(runner): """ make qdevice not start automatically on boot on local host """ external.disable_service(runner, __service_name) def qdevice_start(runner): """ start qdevice now on local host """ external.start_service(runner, __service_name) def qdevice_stop(runner): """ stop qdevice now on local host """ external.stop_service(runner, __service_name) def qdevice_kill(runner): """ kill qdevice now on local host """ external.kill_services(runner, [__service_name]) def qdevice_sign_certificate_request(runner, cert_request, cluster_name): """ sign client certificate request cert_request certificate request data string cluster_name name of the cluster to which qdevice is being added """ if not qdevice_initialized(): raise LibraryError(reports.qdevice_not_initialized(__model)) # save the certificate request, corosync tool only works with files tmpfile = _store_to_tmpfile( cert_request, reports.qdevice_certificate_sign_error ) # sign the request stdout, stderr, retval = runner.run([ __qnetd_certutil, "-s", "-c", tmpfile.name, "-n", cluster_name ]) tmpfile.close() # temp file is deleted on close if retval != 0: raise LibraryError( reports.qdevice_certificate_sign_error( join_multilines([stderr, stdout]) ) ) # get signed certificate, corosync tool only works with files return _get_output_certificate( stdout, reports.qdevice_certificate_sign_error ) def client_setup(runner, ca_certificate): """ initialize qdevice client on local host ca_certificate qnetd CA certificate """ client_destroy() # save CA certificate, corosync tool only works with files ca_file_path = os.path.join( settings.corosync_qdevice_net_client_certs_dir, settings.corosync_qdevice_net_client_ca_file_name ) try: if not os.path.exists(ca_file_path): os.makedirs( settings.corosync_qdevice_net_client_certs_dir, mode=0o700 ) with open(ca_file_path, "wb") as ca_file: ca_file.write(ca_certificate) except EnvironmentError as e: raise LibraryError( reports.qdevice_initialization_error(__model, e.strerror) ) # initialize client's certificate storage stdout, stderr, retval = runner.run([ __qdevice_certutil, "-i", "-c", ca_file_path ]) if retval != 0: raise LibraryError( reports.qdevice_initialization_error( __model, join_multilines([stderr, stdout]) ) ) def client_initialized(): """ check if qdevice net client certificate database has been initialized """ return os.path.exists(os.path.join( settings.corosync_qdevice_net_client_certs_dir, "cert8.db" )) def client_destroy(): """ delete qdevice client config files on local host """ try: if client_initialized(): shutil.rmtree(settings.corosync_qdevice_net_client_certs_dir) except EnvironmentError as e: raise LibraryError( reports.qdevice_destroy_error(__model, e.strerror) ) def client_generate_certificate_request(runner, cluster_name): """ create a certificate request which can be signed by qnetd server string cluster_name name of the cluster to which qdevice is being added """ if not client_initialized(): raise LibraryError(reports.qdevice_not_initialized(__model)) stdout, stderr, retval = runner.run([ __qdevice_certutil, "-r", "-n", cluster_name ]) if retval != 0: raise LibraryError( reports.qdevice_initialization_error( __model, join_multilines([stderr, stdout]) ) ) return _get_output_certificate( stdout, functools.partial(reports.qdevice_initialization_error, __model) ) def client_cert_request_to_pk12(runner, cert_request): """ transform signed certificate request to pk12 certificate which can be imported to nodes cert_request signed certificate request """ if not client_initialized(): raise LibraryError(reports.qdevice_not_initialized(__model)) # save the signed certificate request, corosync tool only works with files tmpfile = _store_to_tmpfile( cert_request, reports.qdevice_certificate_import_error ) # transform it stdout, stderr, retval = runner.run([ __qdevice_certutil, "-M", "-c", tmpfile.name ]) tmpfile.close() # temp file is deleted on close if retval != 0: raise LibraryError( reports.qdevice_certificate_import_error( join_multilines([stderr, stdout]) ) ) # get resulting pk12, corosync tool only works with files return _get_output_certificate( stdout, reports.qdevice_certificate_import_error ) def client_import_certificate_and_key(runner, pk12_certificate): """ import qdevice client certificate to the local node certificate storage """ if not client_initialized(): raise LibraryError(reports.qdevice_not_initialized(__model)) # save the certificate, corosync tool only works with files tmpfile = _store_to_tmpfile( pk12_certificate, reports.qdevice_certificate_import_error ) stdout, stderr, retval = runner.run([ __qdevice_certutil, "-m", "-c", tmpfile.name ]) tmpfile.close() # temp file is deleted on close if retval != 0: raise LibraryError( reports.qdevice_certificate_import_error( join_multilines([stderr, stdout]) ) ) def remote_qdevice_get_ca_certificate(node_communicator, host): """ connect to a qnetd host and get qnetd CA certificate string host address of the qnetd host """ try: return base64.b64decode( node_communicator.call_host( host, "remote/qdevice_net_get_ca_certificate", None ) ) except (TypeError, binascii.Error): raise LibraryError(reports.invalid_response_format(host)) def remote_client_setup(node_communicator, node, qnetd_ca_certificate): """ connect to a remote node and initialize qdevice there NodeAddresses node target node qnetd_ca_certificate qnetd CA certificate """ return node_communicator.call_node( node, "remote/qdevice_net_client_init_certificate_storage", external.NodeCommunicator.format_data_dict([ ("ca_certificate", base64.b64encode(qnetd_ca_certificate)), ]) ) def remote_sign_certificate_request( node_communicator, host, cert_request, cluster_name ): """ connect to a qdevice host and sign node certificate there string host address of the qnetd host cert_request certificate request to be signed string cluster_name name of the cluster to which qdevice is being added """ try: return base64.b64decode( node_communicator.call_host( host, "remote/qdevice_net_sign_node_certificate", external.NodeCommunicator.format_data_dict([ ("certificate_request", base64.b64encode(cert_request)), ("cluster_name", cluster_name), ]) ) ) except (TypeError, binascii.Error): raise LibraryError(reports.invalid_response_format(host)) def remote_client_import_certificate_and_key(node_communicator, node, pk12): """ import pk12 certificate on a remote node NodeAddresses node target node pk12 certificate """ return node_communicator.call_node( node, "remote/qdevice_net_client_import_certificate", external.NodeCommunicator.format_data_dict([ ("certificate", base64.b64encode(pk12)), ]) ) def remote_client_destroy(node_communicator, node): """ delete qdevice client config files on a remote node NodeAddresses node target node """ return node_communicator.call_node( node, "remote/qdevice_net_client_destroy", None ) def _store_to_tmpfile(data, report_func): try: tmpfile = tempfile.NamedTemporaryFile(mode="wb", suffix=".pcs") tmpfile.write(data) tmpfile.flush() return tmpfile except EnvironmentError as e: raise LibraryError(report_func(e.strerror)) def _get_output_certificate(cert_tool_output, report_func): regexp = re.compile(r"^Certificate( request)? stored in (?P.+)$") filename = None for line in cert_tool_output.splitlines(): match = regexp.search(line) if match: filename = match.group("path") if not filename: raise LibraryError(report_func(cert_tool_output)) try: with open(filename, "rb") as cert_file: return cert_file.read() except EnvironmentError as e: raise LibraryError(report_func( "{path}: {error}".format(path=filename, error=e.strerror) )) pcs-0.9.155/pcs/lib/env.py000066400000000000000000000171221301012375000151500ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os.path from lxml import etree from pcs import settings from pcs.lib import reports from pcs.lib.booth.env import BoothEnv from pcs.lib.cib.tools import ensure_cib_version from pcs.lib.cluster_conf_facade import ClusterConfFacade from pcs.lib.corosync.config_facade import ConfigFacade as CorosyncConfigFacade from pcs.lib.corosync.live import ( exists_local_corosync_conf, get_local_corosync_conf, get_local_cluster_conf, reload_config as reload_corosync_config, ) from pcs.lib.external import ( is_cman_cluster, is_service_running, CommandRunner, NodeCommunicator, ) from pcs.lib.errors import LibraryError from pcs.lib.nodes_task import ( distribute_corosync_conf, check_corosync_offline_on_nodes, qdevice_reload_on_nodes, ) from pcs.lib.pacemaker import ( get_cib, get_cib_xml, replace_cib_configuration_xml, ) class LibraryEnvironment(object): # pylint: disable=too-many-instance-attributes def __init__( self, logger, report_processor, user_login=None, user_groups=None, cib_data=None, corosync_conf_data=None, booth=None, auth_tokens_getter=None, cluster_conf_data=None, ): self._logger = logger self._report_processor = report_processor self._user_login = user_login self._user_groups = [] if user_groups is None else user_groups self._cib_data = cib_data self._corosync_conf_data = corosync_conf_data self._cluster_conf_data = cluster_conf_data self._booth = ( BoothEnv(report_processor, booth) if booth is not None else None ) self._is_cman_cluster = None # TODO tokens probably should not be inserted from outside, but we're # postponing dealing with them, because it's not that easy to move # related code currently - it's in pcsd self._auth_tokens_getter = auth_tokens_getter self._auth_tokens = None self._cib_upgraded = False @property def logger(self): return self._logger @property def report_processor(self): return self._report_processor @property def user_login(self): return self._user_login @property def user_groups(self): return self._user_groups @property def is_cman_cluster(self): if self._is_cman_cluster is None: self._is_cman_cluster = is_cman_cluster(self.cmd_runner()) return self._is_cman_cluster @property def cib_upgraded(self): return self._cib_upgraded def _get_cib_xml(self): if self.is_cib_live: return get_cib_xml(self.cmd_runner()) else: return self._cib_data def get_cib(self, minimal_version=None): cib = get_cib(self._get_cib_xml()) if minimal_version is not None: upgraded_cib = ensure_cib_version( self.cmd_runner(), cib, minimal_version ) if upgraded_cib is not None: cib = upgraded_cib self._cib_upgraded = True return cib def _push_cib_xml(self, cib_data): if self.is_cib_live: replace_cib_configuration_xml( self.cmd_runner(), cib_data, self._cib_upgraded ) if self._cib_upgraded: self._cib_upgraded = False self.report_processor.process(reports.cib_upgrade_successful()) else: self._cib_data = cib_data def push_cib(self, cib): #etree returns bytes: b'xml' #python 3 removed .encode() from bytes #run(...) calls subprocess.Popen.communicate which calls encode... #so here is bytes to str conversion self._push_cib_xml(etree.tostring(cib).decode()) @property def is_cib_live(self): return self._cib_data is None def get_corosync_conf_data(self): if self._corosync_conf_data is None: return get_local_corosync_conf() else: return self._corosync_conf_data def get_corosync_conf(self): return CorosyncConfigFacade.from_string(self.get_corosync_conf_data()) def push_corosync_conf( self, corosync_conf_facade, skip_offline_nodes=False ): corosync_conf_data = corosync_conf_facade.config.export() if self.is_corosync_conf_live: node_list = corosync_conf_facade.get_nodes() if corosync_conf_facade.need_stopped_cluster: check_corosync_offline_on_nodes( self.node_communicator(), self.report_processor, node_list, skip_offline_nodes ) distribute_corosync_conf( self.node_communicator(), self.report_processor, node_list, corosync_conf_data, skip_offline_nodes ) if is_service_running(self.cmd_runner(), "corosync"): reload_corosync_config(self.cmd_runner()) self.report_processor.process( reports.corosync_config_reloaded() ) if corosync_conf_facade.need_qdevice_reload: qdevice_reload_on_nodes( self.node_communicator(), self.report_processor, node_list, skip_offline_nodes ) else: self._corosync_conf_data = corosync_conf_data def get_cluster_conf_data(self): if self.is_cluster_conf_live: return get_local_cluster_conf() else: return self._cluster_conf_data def get_cluster_conf(self): return ClusterConfFacade.from_string(self.get_cluster_conf_data()) @property def is_cluster_conf_live(self): return self._cluster_conf_data is None def is_node_in_cluster(self): if self.is_cman_cluster: #TODO --cluster_conf is not propagated here. So no live check not #needed here. But this should not be permanently return os.path.exists(settings.corosync_conf_file) if not self.is_corosync_conf_live: raise AssertionError( "Cannot check if node is in cluster with mocked corosync_conf." ) return exists_local_corosync_conf() def command_expect_live_corosync_env(self): if not self.is_corosync_conf_live: raise LibraryError(reports.live_environment_required([ "--corosync_conf" ])) @property def is_corosync_conf_live(self): return self._corosync_conf_data is None def cmd_runner(self): runner_env = { # make sure to get output of external processes in English and ASCII "LC_ALL": "C", } if self.user_login: runner_env["CIB_user"] = self.user_login return CommandRunner(self.logger, self.report_processor, runner_env) def node_communicator(self): return NodeCommunicator( self.logger, self.report_processor, self.__get_auth_tokens(), self.user_login, self.user_groups ) def __get_auth_tokens(self): if self._auth_tokens is None: if self._auth_tokens_getter: self._auth_tokens = self._auth_tokens_getter() else: self._auth_tokens = {} return self._auth_tokens @property def booth(self): return self._booth pcs-0.9.155/pcs/lib/env_file.py000066400000000000000000000076711301012375000161570ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os.path from pcs.common import report_codes from pcs.common.tools import format_environment_error from pcs.lib import reports from pcs.lib.errors import ReportItemSeverity, LibraryError, LibraryEnvError class GhostFile(object): is_live = False def __init__(self, file_role, content=None): self.__file_role = file_role self.__content = content self.__no_existing_file_expected = False self.__can_overwrite_existing_file = False self.__is_binary = False def read(self): if self.__content is None: raise LibraryEnvError( reports.file_does_not_exist(self.__file_role) ) return self.__content def remove(self, silence_no_existence): raise AssertionError("Remove GhostFile is not supported.") def write(self, content, file_operation=None, is_binary=False): """ callable file_operation is there only for RealFile compatible interface it has no efect """ self.__is_binary = is_binary self.__content = content def assert_no_conflict_with_existing( self, report_processor, can_overwrite_existing=False ): self.__no_existing_file_expected = True self.__can_overwrite_existing_file = can_overwrite_existing def export(self): return { "content": self.__content, "no_existing_file_expected": self.__no_existing_file_expected, "can_overwrite_existing_file": self.__can_overwrite_existing_file, "is_binary": self.__is_binary, } class RealFile(object): is_live = True def __init__( self, file_role, file_path, overwrite_code=report_codes.FORCE_FILE_OVERWRITE ): self.__file_role = file_role self.__file_path = file_path self.__overwrite_code = overwrite_code def assert_no_conflict_with_existing( self, report_processor, can_overwrite_existing=False ): if os.path.exists(self.__file_path): report_processor.process(reports.file_already_exists( self.__file_role, self.__file_path, ReportItemSeverity.WARNING if can_overwrite_existing else ReportItemSeverity.ERROR, forceable=None if can_overwrite_existing else self.__overwrite_code, )) def write(self, content, file_operation=None, is_binary=False): """ callable file_operation takes path and proces operation on it e.g. chmod """ mode = "wb" if is_binary else "w" try: with open(self.__file_path, mode) as config_file: config_file.write(content) if file_operation: file_operation(self.__file_path) except EnvironmentError as e: raise self.__report_io_error(e, "write") def read(self): try: with open(self.__file_path, "r") as file: return file.read() except EnvironmentError as e: raise self.__report_io_error(e, "read") def remove(self, silence_no_existence=False): if os.path.exists(self.__file_path): try: os.remove(self.__file_path) except EnvironmentError as e: raise self.__report_io_error(e, "remove") elif not silence_no_existence: raise LibraryError(reports.file_io_error( self.__file_role, file_path=self.__file_path, operation="remove", reason="File does not exist" )) def __report_io_error(self, e, operation): return LibraryError(reports.file_io_error( self.__file_role, file_path=self.__file_path, operation=operation, reason=format_environment_error(e) )) pcs-0.9.155/pcs/lib/errors.py000066400000000000000000000027561301012375000157030ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) class LibraryError(Exception): pass class LibraryEnvError(LibraryError): def __init__(self, *args, **kwargs): super(LibraryEnvError, self).__init__(*args, **kwargs) self.processed = [] def sign_processed(self, report): self.processed.append(report) @property def unprocessed(self): return [report for report in self.args if report not in self.processed] class ReportItemSeverity(object): ERROR = 'ERROR' WARNING = 'WARNING' INFO = 'INFO' DEBUG = 'DEBUG' class ReportItem(object): @classmethod def error(cls, code, **kwargs): return cls(code, ReportItemSeverity.ERROR, **kwargs) @classmethod def warning(cls, code, **kwargs): return cls(code, ReportItemSeverity.WARNING, **kwargs) @classmethod def info(cls, code, **kwargs): return cls(code, ReportItemSeverity.INFO, **kwargs) @classmethod def debug(cls, code, **kwargs): return cls(code, ReportItemSeverity.DEBUG, **kwargs) def __init__( self, code, severity, forceable=None, info=None ): self.code = code self.severity = severity self.forceable = forceable self.info = info if info else dict() def __repr__(self): return "{severity} {code}: {info}".format( severity=self.severity, code=self.code, info=self.info ) pcs-0.9.155/pcs/lib/exchange_formats.md000066400000000000000000000016051301012375000176440ustar00rootroot00000000000000Exchange formats ================ Library exchanges with the client data in the formats described below. Resource set ------------ Dictionary with keys are "options" and "ids". On the key "options" is a dictionary of resource set options. On the key "ids" is a list of resource id. ```python { "options": {"id": "id"}, "ids": ["resourceA", "resourceB"], } ``` Constraint ---------- When constraint is plain (without resource sets) there is only dictionary with constraint options. ```python {"id": "id", "rsc": "resourceA"} ``` When is constraint with resource sets there is dictionary with keys "resource_sets" and "options". On the key "options" is a dictionary of constraint options. On the key "resource_sets" is a dictionary of resource sets (see Resource set). ```python { "options": {"id": "id"}, "resource_sets": {"options": {"id": "id"}, "ids": ["resourceA", "resourceB"]}, } ``` pcs-0.9.155/pcs/lib/external.py000066400000000000000000000526621301012375000162120ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import base64 import inspect import json import os try: # python 2 from pipes import quote as shell_quote except ImportError: # python 3 from shlex import quote as shell_quote import re import signal import ssl import subprocess import sys try: # python2 from urllib import urlencode as urllib_urlencode except ImportError: # python3 from urllib.parse import urlencode as urllib_urlencode try: # python2 from urllib2 import ( build_opener as urllib_build_opener, HTTPCookieProcessor as urllib_HTTPCookieProcessor, HTTPSHandler as urllib_HTTPSHandler, HTTPError as urllib_HTTPError, URLError as urllib_URLError ) except ImportError: # python3 from urllib.request import ( build_opener as urllib_build_opener, HTTPCookieProcessor as urllib_HTTPCookieProcessor, HTTPSHandler as urllib_HTTPSHandler ) from urllib.error import ( HTTPError as urllib_HTTPError, URLError as urllib_URLError ) from pcs import settings from pcs.common import report_codes from pcs.common.tools import ( join_multilines, simple_cache, run_parallel as tools_run_parallel, ) from pcs.lib import reports from pcs.lib.errors import LibraryError, ReportItemSeverity _chkconfig = settings.chkconfig_binary _service = settings.service_binary _systemctl = settings.systemctl_binary class ManageServiceError(Exception): #pylint: disable=super-init-not-called def __init__(self, service, message=None, instance=None): self.service = service self.message = message self.instance = instance class DisableServiceError(ManageServiceError): pass class EnableServiceError(ManageServiceError): pass class StartServiceError(ManageServiceError): pass class StopServiceError(ManageServiceError): pass class KillServicesError(ManageServiceError): pass def is_dir_nonempty(path): if not os.path.exists(path): return False if not os.path.isdir(path): return True return len(os.listdir(path)) > 0 def _get_service_name(service, instance=None): return "{0}{1}.service".format( service, "" if instance is None else "@{0}".format(instance) ) def ensure_is_systemd(): """ Ensure if current system is systemd system. Raises Library error if not. """ if not is_systemctl(): raise LibraryError( reports.unsupported_operation_on_non_systemd_systems() ) @simple_cache def is_systemctl(): """ Check whenever is local system running on systemd. Returns True if current system is systemctl compatible, False otherwise. """ systemctl_paths = [ '/usr/bin/systemctl', '/bin/systemctl', '/var/run/systemd/system', '/run/systemd/system', ] for path in systemctl_paths: if os.path.exists(path): return True return False def disable_service(runner, service, instance=None): """ Disable specified service in local system. Raise DisableServiceError or LibraryError on failure. runner -- CommandRunner service -- name of service instance -- instance name, it ha no effect on not systemd systems. If None no instance name will be used. """ if not is_service_installed(runner, service): return if is_systemctl(): stdout, stderr, retval = runner.run([ _systemctl, "disable", _get_service_name(service, instance) ]) else: stdout, stderr, retval = runner.run([_chkconfig, service, "off"]) if retval != 0: raise DisableServiceError( service, join_multilines([stderr, stdout]), instance ) def enable_service(runner, service, instance=None): """ Enable specified service in local system. Raise EnableServiceError or LibraryError on failure. runner -- CommandRunner service -- name of service instance -- instance name, it ha no effect on not systemd systems. If None no instance name will be used. """ if is_systemctl(): stdout, stderr, retval = runner.run([ _systemctl, "enable", _get_service_name(service, instance) ]) else: stdout, stderr, retval = runner.run([_chkconfig, service, "on"]) if retval != 0: raise EnableServiceError( service, join_multilines([stderr, stdout]), instance ) def start_service(runner, service, instance=None): """ Start specified service in local system CommandRunner runner string service service name string instance instance name, it ha no effect on not systemd systems. If None no instance name will be used. """ if is_systemctl(): stdout, stderr, retval = runner.run([ _systemctl, "start", _get_service_name(service, instance) ]) else: stdout, stderr, retval = runner.run([_service, service, "start"]) if retval != 0: raise StartServiceError( service, join_multilines([stderr, stdout]), instance ) def stop_service(runner, service, instance=None): """ Stop specified service in local system CommandRunner runner string service service name string instance instance name, it ha no effect on not systemd systems. If None no instance name will be used. """ if is_systemctl(): stdout, stderr, retval = runner.run([ _systemctl, "stop", _get_service_name(service, instance) ]) else: stdout, stderr, retval = runner.run([_service, service, "stop"]) if retval != 0: raise StopServiceError( service, join_multilines([stderr, stdout]), instance ) def kill_services(runner, services): """ Kill specified services in local system CommandRunner runner iterable services service names """ # make killall not report that a process is not running stdout, stderr, retval = runner.run( ["killall", "--quiet", "--signal", "9", "--"] + list(services) ) # If a process isn't running, killall will still return 1 even with --quiet. # We don't consider that an error, so we check for output string as well. # If it's empty, no actuall error happened. if retval != 0: message = join_multilines([stderr, stdout]) if message: raise KillServicesError(list(services), message) def is_service_enabled(runner, service, instance=None): """ Check if specified service is enabled in local system. runner -- CommandRunner service -- name of service """ if is_systemctl(): dummy_stdout, dummy_stderr, retval = runner.run( [_systemctl, "is-enabled", _get_service_name(service, instance)] ) else: dummy_stdout, dummy_stderr, retval = runner.run([_chkconfig, service]) return retval == 0 def is_service_running(runner, service, instance=None): """ Check if specified service is currently running on local system. runner -- CommandRunner service -- name of service """ if is_systemctl(): dummy_stdout, dummy_stderr, retval = runner.run([ _systemctl, "is-active", _get_service_name(service, instance) ]) else: dummy_stdout, dummy_stderr, retval = runner.run( [_service, service, "status"] ) return retval == 0 def is_service_installed(runner, service): """ Check if specified service is installed on local system. runner -- CommandRunner service -- name of service """ if is_systemctl(): return service in get_systemd_services(runner) else: return service in get_non_systemd_services(runner) def get_non_systemd_services(runner): """ Returns list of all installed services on non systemd system. runner -- CommandRunner """ if is_systemctl(): return [] stdout, dummy_stderr, return_code = runner.run([_chkconfig]) if return_code != 0: return [] service_list = [] for service in stdout.splitlines(): service = service.split(" ", 1)[0] if service: service_list.append(service) return service_list def get_systemd_services(runner): """ Returns list of all systemd services installed on local system. runner -- CommandRunner """ if not is_systemctl(): return [] stdout, dummy_stderr, return_code = runner.run([ _systemctl, "list-unit-files", "--full" ]) if return_code != 0: return [] service_list = [] for service in stdout.splitlines(): match = re.search(r'^([\S]*)\.service', service) if match: service_list.append(match.group(1)) return service_list def is_cman_cluster(runner): """ Detect if underlaying locally installed cluster is CMAN based """ # Checking corosync version works in most cases and supports non-rhel # distributions as well as running (manually compiled) corosync2 on rhel6. # - corosync2 does not support cman at all # - corosync1 runs with cman on rhel6 # - corosync1 can be used without cman, but we don't support it anyways # - corosync2 is the default result if errors occur stdout, dummy_stderr, retval = runner.run([ os.path.join(settings.corosync_binaries, "corosync"), "-v" ]) if retval != 0: return False match = re.search(r"version\D+(\d+)", stdout) return match is not None and match.group(1) == "1" class CommandRunner(object): def __init__(self, logger, reporter, env_vars=None): self._logger = logger self._reporter = reporter # Reset environment variables by empty dict is desired here. We need # to get rid of defaults - we do not know the context and environment # where the library runs. We also get rid of PATH settings, so all # executables must be specified with full path unless the PATH variable # is set from outside. self._env_vars = env_vars if env_vars else dict() self._python2 = sys.version[0] == "2" def run( self, args, stdin_string=None, env_extend=None, binary_output=False ): # Allow overriding default settings. If a piece of code really wants to # set own PATH or CIB_file, we must allow it. I.e. it wants to run # a pacemaker tool on a CIB in a file but cannot afford the risk of # changing the CIB in the file specified by the user. env_vars = self._env_vars env_vars.update( dict(env_extend) if env_extend else dict() ) log_args = " ".join([shell_quote(x) for x in args]) msg = "Running: {args}" if stdin_string: msg += "\n--Debug Input Start--\n{stdin}\n--Debug Input End--" self._logger.debug(msg.format(args=log_args, stdin=stdin_string)) self._reporter.process( reports.run_external_process_started(log_args, stdin_string) ) try: process = subprocess.Popen( args, # Some commands react differently if they get anything via stdin stdin=(subprocess.PIPE if stdin_string is not None else None), stdout=subprocess.PIPE, stderr=subprocess.PIPE, preexec_fn=( lambda: signal.signal(signal.SIGPIPE, signal.SIG_DFL) ), close_fds=True, shell=False, env=env_vars, # decodes newlines and in python3 also converts bytes to str universal_newlines=(not self._python2 and not binary_output) ) out_std, out_err = process.communicate(stdin_string) retval = process.returncode except OSError as e: raise LibraryError( reports.run_external_process_error(log_args, e.strerror) ) self._logger.debug( ( "Finished running: {args}\nReturn value: {retval}" + "\n--Debug Stdout Start--\n{out_std}\n--Debug Stdout End--" + "\n--Debug Stderr Start--\n{out_err}\n--Debug Stderr End--" ).format( args=log_args, retval=retval, out_std=out_std, out_err=out_err ) ) self._reporter.process(reports.run_external_process_finished( log_args, retval, out_std, out_err )) return out_std, out_err, retval class NodeCommunicationException(Exception): # pylint: disable=super-init-not-called def __init__(self, node, command, reason): self.node = node self.command = command self.reason = reason class NodeConnectionException(NodeCommunicationException): pass class NodeAuthenticationException(NodeCommunicationException): pass class NodePermissionDeniedException(NodeCommunicationException): pass class NodeCommandUnsuccessfulException(NodeCommunicationException): pass class NodeUnsupportedCommandException(NodeCommunicationException): pass def node_communicator_exception_to_report_item( e, severity=ReportItemSeverity.ERROR, forceable=None ): """ Transform NodeCommunicationException to ReportItem """ if isinstance(e, NodeCommandUnsuccessfulException): return reports.node_communication_command_unsuccessful( e.node, e.command, e.reason ) exception_to_report = { NodeAuthenticationException: reports.node_communication_error_not_authorized, NodePermissionDeniedException: reports.node_communication_error_permission_denied, NodeUnsupportedCommandException: reports.node_communication_error_unsupported_command, NodeCommunicationException: reports.node_communication_error_other_error, NodeConnectionException: reports.node_communication_error_unable_to_connect, } if e.__class__ in exception_to_report: return exception_to_report[e.__class__]( e.node, e.command, e.reason, severity, forceable ) raise e class NodeCommunicator(object): """ Sends requests to nodes """ @classmethod def format_data_dict(cls, data): """ Encode data for transport (only plain dict is supported) """ return urllib_urlencode(data) @classmethod def format_data_json(cls, data): """ Encode data for transport (more complex data than in format_data_dict) """ return json.dumps(data) def __init__(self, logger, reporter, auth_tokens, user=None, groups=None): """ auth_tokens authorization tokens for nodes: {node: token} user username groups groups the user is member of """ self._logger = logger self._reporter = reporter self._auth_tokens = auth_tokens self._user = user self._groups = groups def call_node(self, node_addr, request, data): """ Send a request to a node node_addr destination node, instance of NodeAddresses request command to be run on the node data command parameters, encoded by format_data_* method """ return self.call_host(node_addr.ring0, request, data) def call_host(self, host, request, data): """ Send a request to a host host host address request command to be run on the host data command parameters, encoded by format_data_* method """ opener = self.__get_opener() url = "https://{host}:2224/{request}".format( host=("[{0}]".format(host) if ":" in host else host), request=request ) cookies = self.__prepare_cookies(host) if cookies: opener.addheaders.append(("Cookie", ";".join(cookies))) msg = "Sending HTTP Request to: {url}" if data: msg += "\n--Debug Input Start--\n{data}\n--Debug Input End--" self._logger.debug(msg.format(url=url, data=data)) self._reporter.process( reports.node_communication_started(url, data) ) result_msg = ( "Finished calling: {url}\nResponse Code: {code}" + "\n--Debug Response Start--\n{response}\n--Debug Response End--" ) try: # python3 requires data to be bytes not str if data: data = data.encode("utf-8") result = opener.open(url, data) # python3 returns bytes not str response_data = result.read().decode("utf-8") self._logger.debug(result_msg.format( url=url, code=result.getcode(), response=response_data )) self._reporter.process( reports.node_communication_finished( url, result.getcode(), response_data ) ) return response_data except urllib_HTTPError as e: # python3 returns bytes not str response_data = e.read().decode("utf-8") self._logger.debug(result_msg.format( url=url, code=e.code, response=response_data )) self._reporter.process( reports.node_communication_finished(url, e.code, response_data) ) if e.code == 400: # old pcsd protocol: error messages are commonly passed in plain # text in response body with HTTP code 400 # we need to be backward compatible with that raise NodeCommandUnsuccessfulException( host, request, response_data.rstrip() ) elif e.code == 401: raise NodeAuthenticationException( host, request, "HTTP error: {0}".format(e.code) ) elif e.code == 403: raise NodePermissionDeniedException( host, request, "HTTP error: {0}".format(e.code) ) elif e.code == 404: raise NodeUnsupportedCommandException( host, request, "HTTP error: {0}".format(e.code) ) else: raise NodeCommunicationException( host, request, "HTTP error: {0}".format(e.code) ) except urllib_URLError as e: msg = "Unable to connect to {node} ({reason})" self._logger.debug(msg.format(node=host, reason=e.reason)) self._reporter.process( reports.node_communication_not_connected(host, e.reason) ) raise NodeConnectionException(host, request, e.reason) def __get_opener(self): # enable self-signed certificates # https://www.python.org/dev/peps/pep-0476/ # http://bugs.python.org/issue21308 if ( hasattr(ssl, "_create_unverified_context") and "context" in inspect.getargspec(urllib_HTTPSHandler.__init__).args ): opener = urllib_build_opener( urllib_HTTPSHandler(context=ssl._create_unverified_context()), urllib_HTTPCookieProcessor() ) else: opener = urllib_build_opener(urllib_HTTPCookieProcessor()) return opener def __prepare_cookies(self, host): # Let's be safe about characters in variables (they can come from env) # and do base64. We cannot do it for CIB_user however to be backward # compatible so we at least remove disallowed characters. cookies = [] if host in self._auth_tokens: cookies.append("token={0}".format(self._auth_tokens[host])) if self._user: cookies.append("CIB_user={0}".format( re.sub(r"[^!-~]", "", self._user).replace(";", "") )) if self._groups: cookies.append("CIB_user_groups={0}".format( # python3 requires the value to be bytes not str base64.b64encode(" ".join(self._groups).encode("utf-8")) )) return cookies def parallel_nodes_communication_helper( func, func_args_kwargs, reporter, skip_offline_nodes=False ): """ Help running node calls in parallel and handle communication exceptions. Raise LibraryError on any failure. function func function to be run, should be a function calling a node iterable func_args_kwargs list of tuples: (*args, **kwargs) bool skip_offline_nodes do not raise LibraryError if a node is unreachable """ failure_severity = ReportItemSeverity.ERROR failure_forceable = report_codes.SKIP_OFFLINE_NODES if skip_offline_nodes: failure_severity = ReportItemSeverity.WARNING failure_forceable = None report_items = [] def _parallel(*args, **kwargs): try: func(*args, **kwargs) except NodeCommunicationException as e: report_items.append( node_communicator_exception_to_report_item( e, failure_severity, failure_forceable ) ) except LibraryError as e: report_items.extend(e.args) tools_run_parallel(_parallel, func_args_kwargs) reporter.process_list(report_items) pcs-0.9.155/pcs/lib/node.py000066400000000000000000000031671301012375000153110ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) class NodeNotFound(Exception): pass class NodeAddresses(object): def __init__(self, ring0, ring1=None, name=None, id=None): self._ring0 = ring0 self._ring1 = ring1 self._name = name self._id = id def __hash__(self): return hash(self.label) def __eq__(self, other): return self.label == other.label def __ne__(self, other): return not (self == other) def __lt__(self, other): return self.label < other.label @property def ring0(self): return self._ring0 @property def ring1(self): return self._ring1 @property def name(self): return self._name @property def id(self): return self._id @property def label(self): return self.name if self.name else self.ring0 class NodeAddressesList(object): def __init__(self, node_addrs_list=None): self._list = [] if node_addrs_list: for node_addr in node_addrs_list: self._list.append(node_addr) def append(self, item): self._list.append(item) def __len__(self): return self._list.__len__() def __getitem__(self, key): return self._list.__getitem__(key) def __iter__(self): return self._list.__iter__() def __reversed__(self): return self._list.__reversed__() def find_by_label(self, label): for node in self._list: if node.label == label: return node raise NodeNotFound() pcs-0.9.155/pcs/lib/nodes_task.py000066400000000000000000000130751301012375000165150ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import json from pcs.common import report_codes from pcs.common.tools import run_parallel as tools_run_parallel from pcs.lib import reports from pcs.lib.errors import LibraryError, ReportItemSeverity from pcs.lib.external import ( NodeCommunicator, NodeCommunicationException, node_communicator_exception_to_report_item, parallel_nodes_communication_helper, ) from pcs.lib.corosync import ( live as corosync_live, qdevice_client, ) def distribute_corosync_conf( node_communicator, reporter, node_addr_list, config_text, skip_offline_nodes=False ): """ Send corosync.conf to several cluster nodes node_addr_list nodes to send config to (NodeAddressesList instance) config_text text of corosync.conf skip_offline_nodes don't raise an error if a node communication error occurs """ failure_severity = ReportItemSeverity.ERROR failure_forceable = report_codes.SKIP_OFFLINE_NODES if skip_offline_nodes: failure_severity = ReportItemSeverity.WARNING failure_forceable = None report_items = [] def _parallel(node): try: corosync_live.set_remote_corosync_conf( node_communicator, node, config_text ) reporter.process( reports.corosync_config_accepted_by_node(node.label) ) except NodeCommunicationException as e: report_items.append( node_communicator_exception_to_report_item( e, failure_severity, failure_forceable ) ) report_items.append( reports.corosync_config_distribution_node_error( node.label, failure_severity, failure_forceable ) ) reporter.process(reports.corosync_config_distribution_started()) tools_run_parallel( _parallel, [((node, ), {}) for node in node_addr_list] ) reporter.process_list(report_items) def check_corosync_offline_on_nodes( node_communicator, reporter, node_addr_list, skip_offline_nodes=False ): """ Check corosync is not running on cluster nodes node_addr_list nodes to send config to (NodeAddressesList instance) skip_offline_nodes don't raise an error if a node communication error occurs """ failure_severity = ReportItemSeverity.ERROR failure_forceable = report_codes.SKIP_OFFLINE_NODES if skip_offline_nodes: failure_severity = ReportItemSeverity.WARNING failure_forceable = None report_items = [] def _parallel(node): try: status = node_communicator.call_node(node, "remote/status", None) if not json.loads(status)["corosync"]: reporter.process( reports.corosync_not_running_on_node_ok(node.label) ) else: report_items.append( reports.corosync_running_on_node_fail(node.label) ) except NodeCommunicationException as e: report_items.append( node_communicator_exception_to_report_item( e, failure_severity, failure_forceable ) ) report_items.append( reports.corosync_not_running_check_node_error( node.label, failure_severity, failure_forceable ) ) except (ValueError, LookupError): report_items.append( reports.corosync_not_running_check_node_error( node.label, failure_severity, failure_forceable ) ) reporter.process(reports.corosync_not_running_check_started()) tools_run_parallel( _parallel, [((node, ), {}) for node in node_addr_list] ) reporter.process_list(report_items) def qdevice_reload_on_nodes( node_communicator, reporter, node_addr_list, skip_offline_nodes=False ): """ Reload corosync-qdevice configuration on cluster nodes NodeAddressesList node_addr_list nodes to reload config on bool skip_offline_nodes don't raise an error on node communication errors """ reporter.process(reports.qdevice_client_reload_started()) parallel_params = [ [(reporter, node_communicator, node), {}] for node in node_addr_list ] # catch an exception so we try to start qdevice on nodes where we stopped it report_items = [] try: parallel_nodes_communication_helper( qdevice_client.remote_client_stop, parallel_params, reporter, skip_offline_nodes ) except LibraryError as e: report_items.extend(e.args) try: parallel_nodes_communication_helper( qdevice_client.remote_client_start, parallel_params, reporter, skip_offline_nodes ) except LibraryError as e: report_items.extend(e.args) reporter.process_list(report_items) def node_check_auth(communicator, node): """ Check authentication and online status of 'node'. communicator -- NodeCommunicator node -- NodeAddresses """ communicator.call_node( node, "remote/check_auth", NodeCommunicator.format_data_dict({"check_auth_only": 1}) ) pcs-0.9.155/pcs/lib/pacemaker.py000066400000000000000000000204231301012375000163060ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os.path from lxml import etree from pcs import settings from pcs.common.tools import join_multilines from pcs.lib import reports from pcs.lib.errors import LibraryError from pcs.lib.pacemaker_state import ClusterState __EXITCODE_WAIT_TIMEOUT = 62 __EXITCODE_CIB_SCOPE_VALID_BUT_NOT_PRESENT = 6 __RESOURCE_CLEANUP_OPERATION_COUNT_THRESHOLD = 100 class CrmMonErrorException(LibraryError): pass # syntactic sugar for getting a full path to a pacemaker executable def __exec(name): return os.path.join(settings.pacemaker_binaries, name) def get_cluster_status_xml(runner): stdout, stderr, retval = runner.run( [__exec("crm_mon"), "--one-shot", "--as-xml", "--inactive"] ) if retval != 0: raise CrmMonErrorException( reports.cluster_state_cannot_load(join_multilines([stderr, stdout])) ) return stdout def get_cib_xml(runner, scope=None): command = [__exec("cibadmin"), "--local", "--query"] if scope: command.append("--scope={0}".format(scope)) stdout, stderr, retval = runner.run(command) if retval != 0: if retval == __EXITCODE_CIB_SCOPE_VALID_BUT_NOT_PRESENT and scope: raise LibraryError( reports.cib_load_error_scope_missing( scope, join_multilines([stderr, stdout]) ) ) else: raise LibraryError( reports.cib_load_error(join_multilines([stderr, stdout])) ) return stdout def get_cib(xml): try: return etree.fromstring(xml) except (etree.XMLSyntaxError, etree.DocumentInvalid): raise LibraryError(reports.cib_load_error_invalid_format()) def replace_cib_configuration_xml(runner, xml, cib_upgraded=False): cmd = [__exec("cibadmin"), "--replace", "--verbose", "--xml-pipe"] if not cib_upgraded: cmd += ["--scope", "configuration"] stdout, stderr, retval = runner.run(cmd, stdin_string=xml) if retval != 0: raise LibraryError(reports.cib_push_error(stderr, stdout)) def replace_cib_configuration(runner, tree, cib_upgraded=False): #etree returns bytes: b'xml' #python 3 removed .encode() from bytes #run(...) calls subprocess.Popen.communicate which calls encode... #so here is bytes to str conversion xml = etree.tostring(tree).decode() return replace_cib_configuration_xml(runner, xml, cib_upgraded) def get_local_node_status(runner): try: cluster_status = ClusterState(get_cluster_status_xml(runner)) except CrmMonErrorException: return {"offline": True} node_name = __get_local_node_name(runner) for node_status in cluster_status.node_section.nodes: if node_status.attrs.name == node_name: result = { "offline": False, } for attr in ( 'id', 'name', 'type', 'online', 'standby', 'standby_onfail', 'maintenance', 'pending', 'unclean', 'shutdown', 'expected_up', 'is_dc', 'resources_running', ): result[attr] = getattr(node_status.attrs, attr) return result raise LibraryError(reports.node_not_found(node_name)) def resource_cleanup(runner, resource=None, node=None, force=False): if not force and not node and not resource: summary = ClusterState(get_cluster_status_xml(runner)).summary operations = summary.nodes.attrs.count * summary.resources.attrs.count if operations > __RESOURCE_CLEANUP_OPERATION_COUNT_THRESHOLD: raise LibraryError( reports.resource_cleanup_too_time_consuming( __RESOURCE_CLEANUP_OPERATION_COUNT_THRESHOLD ) ) cmd = [__exec("crm_resource"), "--cleanup"] if resource: cmd.extend(["--resource", resource]) if node: cmd.extend(["--node", node]) stdout, stderr, retval = runner.run(cmd) if retval != 0: raise LibraryError( reports.resource_cleanup_error( join_multilines([stderr, stdout]), resource, node ) ) # usefull output (what has been done) goes to stderr return join_multilines([stdout, stderr]) def nodes_standby(runner, node_list=None, all_nodes=False): return __nodes_standby_unstandby(runner, True, node_list, all_nodes) def nodes_unstandby(runner, node_list=None, all_nodes=False): return __nodes_standby_unstandby(runner, False, node_list, all_nodes) def has_resource_wait_support(runner): # returns 1 on success so we don't care about retval stdout, stderr, dummy_retval = runner.run( [__exec("crm_resource"), "-?"] ) # help goes to stderr but we check stdout as well if that gets changed return "--wait" in stderr or "--wait" in stdout def ensure_resource_wait_support(runner): if not has_resource_wait_support(runner): raise LibraryError(reports.resource_wait_not_supported()) def wait_for_resources(runner, timeout=None): args = [__exec("crm_resource"), "--wait"] if timeout is not None: args.append("--timeout={0}".format(timeout)) stdout, stderr, retval = runner.run(args) if retval != 0: # Usefull info goes to stderr - not only error messages, a list of # pending actions in case of timeout goes there as well. # We use stdout just to be sure if that's get changed. if retval == __EXITCODE_WAIT_TIMEOUT: raise LibraryError( reports.resource_wait_timed_out( join_multilines([stderr, stdout]) ) ) else: raise LibraryError( reports.resource_wait_error( join_multilines([stderr, stdout]) ) ) def __nodes_standby_unstandby( runner, standby=True, node_list=None, all_nodes=False ): if node_list or all_nodes: # TODO once we switch to editing CIB instead of running crm_stanby, we # cannot always relly on getClusterState. If we're not editing a CIB # from a live cluster, there is no status. state = ClusterState(get_cluster_status_xml(runner)).node_section.nodes known_nodes = [node.attrs.name for node in state] if all_nodes: node_list = known_nodes elif node_list: report = [] for node in node_list: if node not in known_nodes: report.append(reports.node_not_found(node)) if report: raise LibraryError(*report) # TODO Edit CIB directly instead of running commands for each node; be aware # remote nodes might not be in the CIB yet so we need to put them there. cmd_template = [__exec("crm_standby")] cmd_template.extend(["-v", "on"] if standby else ["-D"]) cmd_list = [] if node_list: for node in node_list: cmd_list.append(cmd_template + ["-N", node]) else: cmd_list.append(cmd_template) report = [] for cmd in cmd_list: stdout, stderr, retval = runner.run(cmd) if retval != 0: report.append( reports.common_error(join_multilines([stderr, stdout])) ) if report: raise LibraryError(*report) def __get_local_node_name(runner): # It would be possible to run "crm_node --name" to get the name in one call, # but it returns false names when cluster is not running (or we are on # a remote node). Getting node id first is reliable since it fails in those # cases. stdout, dummy_stderr, retval = runner.run( [__exec("crm_node"), "--cluster-id"] ) if retval != 0: raise LibraryError( reports.pacemaker_local_node_name_not_found("node id not found") ) node_id = stdout.strip() stdout, dummy_stderr, retval = runner.run( [__exec("crm_node"), "--name-for-id={0}".format(node_id)] ) if retval != 0: raise LibraryError( reports.pacemaker_local_node_name_not_found("node name not found") ) node_name = stdout.strip() if node_name == "(null)": raise LibraryError( reports.pacemaker_local_node_name_not_found("node name is null") ) return node_name pcs-0.9.155/pcs/lib/pacemaker_state.py000066400000000000000000000110241301012375000175030ustar00rootroot00000000000000''' The intention is put there knowledge about cluster state structure. Hide information about underlaying xml is desired too. ''' from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os.path from lxml import etree from pcs import settings from pcs.lib import reports from pcs.lib.errors import LibraryError from pcs.lib.pacemaker_values import is_true class _Attrs(object): def __init__(self, owner_name, attrib, required_attrs): ''' attrib lxml.etree._Attrib - wrapped attribute collection required_attrs dict of required atribute names object_name:xml_attribute ''' self.owner_name = owner_name self.attrib = attrib self.required_attrs = required_attrs def __getattr__(self, name): if name in self.required_attrs.keys(): try: attr_specification = self.required_attrs[name] if isinstance(attr_specification, tuple): attr_name, attr_transform = attr_specification return attr_transform(self.attrib[attr_name]) else: return self.attrib[attr_specification] except KeyError: raise AttributeError( "Missing attribute '{0}' ('{1}' in source) in '{2}'" .format(name, self.required_attrs[name], self.owner_name) ) raise AttributeError( "'{0}' does not declare attribute '{1}'" .format(self.owner_name, name) ) class _Children(object): def __init__(self, owner_name, dom_part, children, sections): self.owner_name = owner_name self.dom_part = dom_part self.children = children self.sections = sections def __getattr__(self, name): if name in self.children.keys(): element_name, wrapper = self.children[name] return [ wrapper(element) for element in self.dom_part.findall('.//' + element_name) ] if name in self.sections.keys(): element_name, wrapper = self.sections[name] return wrapper(self.dom_part.findall('.//' + element_name)[0]) raise AttributeError( "'{0}' does not declare child or section '{1}'" .format(self.owner_name, name) ) class _Element(object): required_attrs = {} children = {} sections = {} def __init__(self, dom_part): self.dom_part = dom_part self.attrs = _Attrs( self.__class__.__name__, self.dom_part.attrib, self.required_attrs ) self.children_access = _Children( self.__class__.__name__, self.dom_part, self.children, self.sections, ) def __getattr__(self, name): return getattr(self.children_access, name) class _SummaryNodes(_Element): required_attrs = { 'count': ('number', int), } class _SummaryResources(_Element): required_attrs = { 'count': ('number', int), } class _SummarySection(_Element): sections = { 'nodes': ('nodes_configured', _SummaryNodes), 'resources': ('resources_configured', _SummaryResources), } class _Node(_Element): required_attrs = { 'id': 'id', 'name': 'name', 'type': 'type', 'online': ('online', is_true), 'standby': ('standby', is_true), 'standby_onfail': ('standby_onfail', is_true), 'maintenance': ('maintenance', is_true), 'pending': ('pending', is_true), 'unclean': ('unclean', is_true), 'shutdown': ('shutdown', is_true), 'expected_up': ('expected_up', is_true), 'is_dc': ('is_dc', is_true), 'resources_running': ('resources_running', int), } class _NodeSection(_Element): children = { 'nodes': ('node', _Node), } def _get_valid_cluster_state_dom(xml): try: dom = etree.fromstring(xml) if os.path.isfile(settings.crm_mon_schema): etree.RelaxNG(file=settings.crm_mon_schema).assertValid(dom) return dom except (etree.XMLSyntaxError, etree.DocumentInvalid): raise LibraryError(reports.cluster_state_invalid_format()) class ClusterState(_Element): sections = { 'summary': ('summary', _SummarySection), 'node_section': ('nodes', _NodeSection), } def __init__(self, xml): self.dom = _get_valid_cluster_state_dom(xml) super(ClusterState, self).__init__(self.dom) pcs-0.9.155/pcs/lib/pacemaker_values.py000066400000000000000000000057321301012375000176730ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import re from pcs.lib import reports from pcs.lib.errors import LibraryError __BOOLEAN_TRUE = ["true", "on", "yes", "y", "1"] __BOOLEAN_FALSE = ["false", "off", "no", "n", "0"] SCORE_INFINITY = "INFINITY" def is_true(val): """ Does pacemaker consider a value to be true? See crm_is_true in pacemaker/lib/common/utils.c var checked value """ return val.lower() in __BOOLEAN_TRUE def is_boolean(val): """ Does pacemaker consider a value to be a boolean? See crm_is_true in pacemaker/lib/common/utils.c val checked value """ return val.lower() in __BOOLEAN_TRUE + __BOOLEAN_FALSE def timeout_to_seconds(timeout, return_unknown=False): """ Transform pacemaker style timeout to number of seconds timeout timeout string return_unknown if timeout is not valid then return None on False or timeout on True (default False) """ if timeout.isdigit(): return int(timeout) suffix_multiplier = { "s": 1, "sec": 1, "m": 60, "min": 60, "h": 3600, "hr": 3600, } for suffix, multiplier in suffix_multiplier.items(): if timeout.endswith(suffix) and timeout[:-len(suffix)].isdigit(): return int(timeout[:-len(suffix)]) * multiplier return timeout if return_unknown else None def get_valid_timeout_seconds(timeout_candidate): """ Transform pacemaker style timeout to number of seconds, raise LibraryError on invalid timeout timeout_candidate timeout string or None """ if timeout_candidate is None: return None wait_timeout = timeout_to_seconds(timeout_candidate) if wait_timeout is None: raise LibraryError(reports.invalid_timeout(timeout_candidate)) return wait_timeout def validate_id(id_candidate, description="id"): """ Validate a pacemaker id, raise LibraryError on invalid id. id_candidate id's value description id's role description (default "id") """ # see NCName definition # http://www.w3.org/TR/REC-xml-names/#NT-NCName # http://www.w3.org/TR/REC-xml/#NT-Name if len(id_candidate) < 1: raise LibraryError(reports.invalid_id_is_empty( id_candidate, description )) first_char_re = re.compile("[a-zA-Z_]") if not first_char_re.match(id_candidate[0]): raise LibraryError(reports.invalid_id_bad_char( id_candidate, description, id_candidate[0], True )) char_re = re.compile("[a-zA-Z0-9_.-]") for char in id_candidate[1:]: if not char_re.match(char): raise LibraryError(reports.invalid_id_bad_char( id_candidate, description, char, False )) def is_score_value(value): if not value: return False unsigned_value = value[1:] if value[0] in ("+", "-") else value return unsigned_value == SCORE_INFINITY or unsigned_value.isdigit() pcs-0.9.155/pcs/lib/reports.py000066400000000000000000001331071301012375000160600ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.common import report_codes from pcs.lib.errors import ReportItem, ReportItemSeverity def common_error(text): # TODO replace by more specific reports """ unspecified error with text message, do not use unless absolutely necessary """ return ReportItem.error( report_codes.COMMON_ERROR, info={"text": text} ) def common_info(text): # TODO replace by more specific reports """ unspecified info with text message, do not use unless absolutely necessary """ return ReportItem.info( report_codes.COMMON_INFO, info={"text": text} ) def resource_for_constraint_is_multiinstance( resource_id, parent_type, parent_id, severity=ReportItemSeverity.ERROR, forceable=None ): """ when setting up a constraint a resource in a clone or a master was specified resource_id string specified resource parent_type string "clone" or "master" parent_id clone or master resource id severity report item severity forceable is this report item forceable? by what cathegory? """ return ReportItem( report_codes.RESOURCE_FOR_CONSTRAINT_IS_MULTIINSTANCE, severity, info={ "resource_id": resource_id, "parent_type": parent_type, "parent_id": parent_id, }, forceable=forceable ) def duplicate_constraints_exist( constraint_type, constraint_info_list, severity=ReportItemSeverity.ERROR, forceable=None ): """ when creating a constraint it was detected the constraint already exists constraint_type string "rsc_colocation", "rsc_order", "rsc_ticket" constraint_info_list list of structured constraint data according to type severity report item severity forceable is this report item forceable? by what cathegory? """ return ReportItem( report_codes.DUPLICATE_CONSTRAINTS_EXIST, severity, info={ "constraint_type": constraint_type, "constraint_info_list": constraint_info_list, }, forceable=forceable ) def empty_resource_set_list(): """ an empty resource set has been specified, which is not allowed by cib schema """ return ReportItem.error( report_codes.EMPTY_RESOURCE_SET_LIST, ) def required_option_is_missing(name): """ required option has not been specified, command cannot continue """ return ReportItem.error( report_codes.REQUIRED_OPTION_IS_MISSING, info={ "option_name": name } ) def invalid_option( option_name, allowed_options, option_type, severity=ReportItemSeverity.ERROR, forceable=None ): """ specified option name is not valid, usualy an error or a warning option_name specified invalid option name allowed_options iterable of possible allowed option names option_type decsribes the option severity report item severity forceable is this report item forceable? by what cathegory? """ return ReportItem( report_codes.INVALID_OPTION, severity, forceable, info={ "option_name": option_name, "option_type": option_type, "allowed": sorted(allowed_options), } ) def invalid_option_value( option_name, option_value, allowed_values, severity=ReportItemSeverity.ERROR, forceable=None ): """ specified value is not valid for the option, usualy an error or a warning option_name specified option name whose value is not valid option_value specified value which is not valid allowed_options list of allowed values or string description severity report item severity forceable is this report item forceable? by what cathegory? """ return ReportItem( report_codes.INVALID_OPTION_VALUE, severity, info={ "option_value": option_value, "option_name": option_name, "allowed_values": allowed_values, }, forceable=forceable ) def invalid_id_is_empty(id, id_description): """ empty string was specified as an id, which is not valid id string specified id id_description string decribe id's role """ return ReportItem.error( report_codes.EMPTY_ID, info={ "id": id, "id_description": id_description, } ) def invalid_id_bad_char(id, id_description, bad_char, is_first_char): """ specified id is not valid as it contains a forbidden character id string specified id id_description string decribe id's role bad_char forbidden character is_first_char is it the first character which is forbidden? """ return ReportItem.error( report_codes.INVALID_ID, info={ "id": id, "id_description": id_description, "is_first_char": is_first_char, "invalid_character": bad_char, } ) def invalid_timeout(timeout): """ specified timeout is not valid (number or other format e.g. 2min) timeout string specified invalid timeout """ return ReportItem.error( report_codes.INVALID_TIMEOUT_VALUE, info={"timeout": timeout} ) def invalid_score(score): """ specified score value is not valid score specified score value """ return ReportItem.error( report_codes.INVALID_SCORE, info={ "score": score, } ) def multiple_score_options(): """ more than one of mutually exclusive score options has been set (score, score-attribute, score-attribute-mangle in rules or colocation sets) """ return ReportItem.error( report_codes.MULTIPLE_SCORE_OPTIONS, ) def run_external_process_started(command, stdin): """ information about running an external process command string the external process command stdin string passed to the external process via its stdin """ return ReportItem.debug( report_codes.RUN_EXTERNAL_PROCESS_STARTED, info={ "command": command, "stdin": stdin, } ) def run_external_process_finished(command, retval, stdout, stderr): """ information about result of running an external process command string the external process command retval external process's return (exit) code stdout string external process's stdout stderr string external process's stderr """ return ReportItem.debug( report_codes.RUN_EXTERNAL_PROCESS_FINISHED, info={ "command": command, "return_value": retval, "stdout": stdout, "stderr": stderr, } ) def run_external_process_error(command, reason): """ attempt to run an external process failed command string the external process command reason string error description """ return ReportItem.error( report_codes.RUN_EXTERNAL_PROCESS_ERROR, info={ "command": command, "reason": reason } ) def node_communication_started(target, data): """ request is about to be sent to a remote node, debug info target string where the request is about to be sent to data string request's data """ return ReportItem.debug( report_codes.NODE_COMMUNICATION_STARTED, info={ "target": target, "data": data, } ) def node_communication_finished(target, retval, data): """ remote node request has been finished, debug info target string where the request was sent to retval response return code data response data """ return ReportItem.debug( report_codes.NODE_COMMUNICATION_FINISHED, info={ "target": target, "response_code": retval, "response_data": data } ) def node_communication_not_connected(node, reason): """ an error occured when connecting to a remote node, debug info node string node address / name reason string decription of the error """ return ReportItem.debug( report_codes.NODE_COMMUNICATION_NOT_CONNECTED, info={ "node": node, "reason": reason, } ) def node_communication_error_not_authorized( node, command, reason, severity=ReportItemSeverity.ERROR, forceable=None ): """ node rejected a request as we are not authorized node string node address / name reason string decription of the error """ return ReportItem( report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, severity, info={ "node": node, "command": command, "reason": reason, }, forceable=forceable ) def node_communication_error_permission_denied( node, command, reason, severity=ReportItemSeverity.ERROR, forceable=None ): """ node rejected a request as we do not have permissions to run the request node string node address / name reason string decription of the error """ return ReportItem( report_codes.NODE_COMMUNICATION_ERROR_PERMISSION_DENIED, severity, info={ "node": node, "command": command, "reason": reason, }, forceable=forceable ) def node_communication_error_unsupported_command( node, command, reason, severity=ReportItemSeverity.ERROR, forceable=None ): """ node rejected a request as it does not support the request node string node address / name reason string decription of the error """ return ReportItem( report_codes.NODE_COMMUNICATION_ERROR_UNSUPPORTED_COMMAND, severity, info={ "node": node, "command": command, "reason": reason, }, forceable=forceable ) def node_communication_command_unsuccessful(node, command, reason): """ node rejected a request for another reason with a plain text explanation node string node address / name reason string decription of the error """ return ReportItem.error( report_codes.NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL, info={ "node": node, "command": command, "reason": reason, } ) def node_communication_error_other_error( node, command, reason, severity=ReportItemSeverity.ERROR, forceable=None ): """ node rejected a request for another reason (may be faulty node) node string node address / name reason string decription of the error """ return ReportItem( report_codes.NODE_COMMUNICATION_ERROR, severity, info={ "node": node, "command": command, "reason": reason, }, forceable=forceable ) def node_communication_error_unable_to_connect( node, command, reason, severity=ReportItemSeverity.ERROR, forceable=None ): """ we were unable to connect to a node node string node address / name reason string decription of the error """ return ReportItem( report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT, severity, info={ "node": node, "command": command, "reason": reason, }, forceable=forceable ) def corosync_config_distribution_started(): """ corosync configuration is about to be sent to nodes """ return ReportItem.info( report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED, ) def corosync_config_accepted_by_node(node): """ corosync configuration has been accepted by a node node string node address / name """ return ReportItem.info( report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE, info={"node": node} ) def corosync_config_distribution_node_error( node, severity=ReportItemSeverity.ERROR, forceable=None ): """ communication error occured when saving corosync configuration to a node node string faulty node address / name """ return ReportItem( report_codes.COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR, severity, info={"node": node}, forceable=forceable ) def corosync_not_running_check_started(): """ we are about to make sure corosync is not running on nodes """ return ReportItem.info( report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED, ) def corosync_not_running_check_node_error( node, severity=ReportItemSeverity.ERROR, forceable=None ): """ communication error occured when checking corosync is not running on a node node string faulty node address / name """ return ReportItem( report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR, severity, info={"node": node}, forceable=forceable ) def corosync_not_running_on_node_ok(node): """ corosync is not running on a node, which is ok node string node address / name """ return ReportItem.info( report_codes.COROSYNC_NOT_RUNNING_ON_NODE, info={"node": node} ) def corosync_running_on_node_fail(node): """ corosync is running on a node, which is not ok node string node address / name """ return ReportItem.error( report_codes.COROSYNC_RUNNING_ON_NODE, info={"node": node} ) def corosync_quorum_get_status_error(reason): """ unable to get runtime status of quorum on local node string reason an error message """ return ReportItem.error( report_codes.COROSYNC_QUORUM_GET_STATUS_ERROR, info={ "reason": reason, } ) def corosync_quorum_set_expected_votes_error(reason): """ unable to set expcted votes in a live cluster string reason an error message """ return ReportItem.error( report_codes.COROSYNC_QUORUM_SET_EXPECTED_VOTES_ERROR, info={ "reason": reason, } ) def corosync_config_reloaded(): """ corosync configuration has been reloaded """ return ReportItem.info( report_codes.COROSYNC_CONFIG_RELOADED, ) def corosync_config_reload_error(reason): """ an error occured when reloading corosync configuration reason string an error message """ return ReportItem.error( report_codes.COROSYNC_CONFIG_RELOAD_ERROR, info={"reason": reason} ) def corosync_config_read_error(path, reason): """ an error occured when reading corosync configuration file from disk reason string an error message """ return ReportItem.error( report_codes.UNABLE_TO_READ_COROSYNC_CONFIG, info={ "path": path, "reason": reason, } ) def corosync_config_parser_missing_closing_brace(): """ corosync config cannot be parsed due to missing closing brace """ return ReportItem.error( report_codes.PARSE_ERROR_COROSYNC_CONF_MISSING_CLOSING_BRACE, ) def corosync_config_parser_unexpected_closing_brace(): """ corosync config cannot be parsed due to unexpected closing brace """ return ReportItem.error( report_codes.PARSE_ERROR_COROSYNC_CONF_UNEXPECTED_CLOSING_BRACE, ) def corosync_config_parser_other_error(): """ corosync config cannot be parsed, the cause is not specified It is better to use more specific error if possible. """ return ReportItem.error( report_codes.PARSE_ERROR_COROSYNC_CONF, ) def corosync_options_incompatible_with_qdevice(options): """ cannot set specified corosync options when qdevice is in use iterable options incompatible options names """ return ReportItem.error( report_codes.COROSYNC_OPTIONS_INCOMPATIBLE_WITH_QDEVICE, info={ "options_names": options, } ) def qdevice_already_defined(): """ qdevice is already set up in a cluster, when it was expected not to be """ return ReportItem.error( report_codes.QDEVICE_ALREADY_DEFINED, ) def qdevice_not_defined(): """ qdevice is not set up in a cluster, when it was expected to be """ return ReportItem.error( report_codes.QDEVICE_NOT_DEFINED, ) def qdevice_remove_or_cluster_stop_needed(): """ operation cannot be executed, qdevice removal or cluster stop is needed """ return ReportItem.error( report_codes.QDEVICE_REMOVE_OR_CLUSTER_STOP_NEEDED, ) def qdevice_client_reload_started(): """ qdevice client configuration is about to be reloaded on nodes """ return ReportItem.info( report_codes.QDEVICE_CLIENT_RELOAD_STARTED, ) def qdevice_already_initialized(model): """ cannot create qdevice on local host, it has been already created string model qdevice model """ return ReportItem.error( report_codes.QDEVICE_ALREADY_INITIALIZED, info={ "model": model, } ) def qdevice_not_initialized(model): """ cannot work with qdevice on local host, it has not been created yet string model qdevice model """ return ReportItem.error( report_codes.QDEVICE_NOT_INITIALIZED, info={ "model": model, } ) def qdevice_initialization_success(model): """ qdevice was successfully initialized on local host string model qdevice model """ return ReportItem.info( report_codes.QDEVICE_INITIALIZATION_SUCCESS, info={ "model": model, } ) def qdevice_initialization_error(model, reason): """ an error occured when creating qdevice on local host string model qdevice model string reason an error message """ return ReportItem.error( report_codes.QDEVICE_INITIALIZATION_ERROR, info={ "model": model, "reason": reason, } ) def qdevice_certificate_distribution_started(): """ Qdevice certificates are about to be set up on nodes """ return ReportItem.info( report_codes.QDEVICE_CERTIFICATE_DISTRIBUTION_STARTED, ) def qdevice_certificate_accepted_by_node(node): """ Qdevice certificates have been saved to a node string node node on which certificates have been saved """ return ReportItem.info( report_codes.QDEVICE_CERTIFICATE_ACCEPTED_BY_NODE, info={"node": node} ) def qdevice_certificate_removal_started(): """ Qdevice certificates are about to be removed from nodes """ return ReportItem.info( report_codes.QDEVICE_CERTIFICATE_REMOVAL_STARTED, ) def qdevice_certificate_removed_from_node(node): """ Qdevice certificates have been removed from a node string node node on which certificates have been deleted """ return ReportItem.info( report_codes.QDEVICE_CERTIFICATE_REMOVED_FROM_NODE, info={"node": node} ) def qdevice_certificate_import_error(reason): """ an error occured when importing qdevice certificate to a node string reason an error message """ return ReportItem.error( report_codes.QDEVICE_CERTIFICATE_IMPORT_ERROR, info={ "reason": reason, } ) def qdevice_certificate_sign_error(reason): """ an error occured when signing qdevice certificate string reason an error message """ return ReportItem.error( report_codes.QDEVICE_CERTIFICATE_SIGN_ERROR, info={ "reason": reason, } ) def qdevice_destroy_success(model): """ qdevice configuration successfully removed from local host string model qdevice model """ return ReportItem.info( report_codes.QDEVICE_DESTROY_SUCCESS, info={ "model": model, } ) def qdevice_destroy_error(model, reason): """ an error occured when removing qdevice configuration from local host string model qdevice model string reason an error message """ return ReportItem.error( report_codes.QDEVICE_DESTROY_ERROR, info={ "model": model, "reason": reason, } ) def qdevice_not_running(model): """ qdevice is expected to be running but is not running string model qdevice model """ return ReportItem.error( report_codes.QDEVICE_NOT_RUNNING, info={ "model": model, } ) def qdevice_get_status_error(model, reason): """ unable to get runtime status of qdevice string model qdevice model string reason an error message """ return ReportItem.error( report_codes.QDEVICE_GET_STATUS_ERROR, info={ "model": model, "reason": reason, } ) def qdevice_used_by_clusters( clusters, severity=ReportItemSeverity.ERROR, forceable=None ): """ Qdevice is currently being used by clusters, cannot stop it unless forced """ return ReportItem( report_codes.QDEVICE_USED_BY_CLUSTERS, severity, info={ "clusters": clusters, }, forceable=forceable ) def cman_unsupported_command(): """ requested library command is not available as local cluster is CMAN based """ return ReportItem.error( report_codes.CMAN_UNSUPPORTED_COMMAND, ) def id_already_exists(id): """ specified id already exists in CIB and cannot be used for a new CIB object id string existing id """ return ReportItem.error( report_codes.ID_ALREADY_EXISTS, info={"id": id} ) def id_not_found(id, id_description): """ specified id does not exist in CIB, user referenced a nonexisting id use "resource_does_not_exist" if id is a resource id id string specified id id_description string decribe id's role """ return ReportItem.error( report_codes.ID_NOT_FOUND, info={ "id": id, "id_description": id_description, } ) def resource_does_not_exist(resource_id): """ specified resource does not exist (e.g. when creating in constraints) resource_id string specified resource id """ return ReportItem.error( report_codes.RESOURCE_DOES_NOT_EXIST, info={ "resource_id": resource_id, } ) def cib_load_error(reason): """ cannot load cib from cibadmin, cibadmin exited with non-zero code string reason error description """ return ReportItem.error( report_codes.CIB_LOAD_ERROR, info={ "reason": reason, } ) def cib_load_error_scope_missing(scope, reason): """ cannot load cib from cibadmin, specified scope is missing in the cib scope string requested cib scope string reason error description """ return ReportItem.error( report_codes.CIB_LOAD_ERROR_SCOPE_MISSING, info={ "scope": scope, "reason": reason, } ) def cib_load_error_invalid_format(): """ cib does not conform to the schema """ return ReportItem.error( report_codes.CIB_LOAD_ERROR_BAD_FORMAT, ) def cib_missing_mandatory_section(section_name): """ CIB is missing a section which is required to be present section_name string name of the missing section (element name or path) """ return ReportItem.error( report_codes.CIB_CANNOT_FIND_MANDATORY_SECTION, info={ "section": section_name, } ) def cib_push_error(reason, pushed_cib): """ cannot push cib to cibadmin, cibadmin exited with non-zero code string reason error description string pushed_cib cib which failed to be pushed """ return ReportItem.error( report_codes.CIB_PUSH_ERROR, info={ "reason": reason, "pushed_cib": pushed_cib, } ) def cluster_state_cannot_load(reason): """ cannot load cluster status from crm_mon, crm_mon exited with non-zero code string reason error description """ return ReportItem.error( report_codes.CRM_MON_ERROR, info={ "reason": reason, } ) def cluster_state_invalid_format(): """ crm_mon xml output does not conform to the schema """ return ReportItem.error( report_codes.BAD_CLUSTER_STATE_FORMAT, ) def resource_wait_not_supported(): """ crm_resource does not support --wait """ return ReportItem.error( report_codes.RESOURCE_WAIT_NOT_SUPPORTED, ) def resource_wait_timed_out(reason): """ waiting for resources (crm_resource --wait) failed, timeout expired string reason error description """ return ReportItem.error( report_codes.RESOURCE_WAIT_TIMED_OUT, info={ "reason": reason, } ) def resource_wait_error(reason): """ waiting for resources (crm_resource --wait) failed string reason error description """ return ReportItem.error( report_codes.RESOURCE_WAIT_ERROR, info={ "reason": reason, } ) def resource_cleanup_error(reason, resource=None, node=None): """ an error occured when deleting resource history in pacemaker string reason error description string resource resource which has been cleaned up string node node which has been cleaned up """ return ReportItem.error( report_codes.RESOURCE_CLEANUP_ERROR, info={ "reason": reason, "resource": resource, "node": node, } ) def resource_cleanup_too_time_consuming(threshold): """ resource cleanup will execute more than threshold operations in a cluster threshold current threshold for trigerring this error """ return ReportItem.error( report_codes.RESOURCE_CLEANUP_TOO_TIME_CONSUMING, info={"threshold": threshold}, forceable=report_codes.FORCE_LOAD_THRESHOLD ) def node_not_found(node): """ specified node does not exist node string specified node """ return ReportItem.error( report_codes.NODE_NOT_FOUND, info={"node": node} ) def pacemaker_local_node_name_not_found(reason): """ we are unable to figure out pacemaker's local node's name reason string error message """ return ReportItem.error( report_codes.PACEMAKER_LOCAL_NODE_NAME_NOT_FOUND, info={"reason": reason} ) def rrp_active_not_supported(warning=False): """ active RRP mode is not supported, require user confirmation warning set to True if user confirmed he/she wants to proceed """ return ReportItem( report_codes.RRP_ACTIVE_NOT_SUPPORTED, ReportItemSeverity.WARNING if warning else ReportItemSeverity.ERROR, forceable=(None if warning else report_codes.FORCE_ACTIVE_RRP) ) def cman_ignored_option(option): """ specified option is ignored as CMAN clusters do not support it options string option name """ return ReportItem.warning( report_codes.IGNORED_CMAN_UNSUPPORTED_OPTION, info={'option_name': option} ) def rrp_addresses_transport_mismatch(): """ RRP defined by network addresses is not allowed when udp transport is used """ return ReportItem.error( report_codes.NON_UDP_TRANSPORT_ADDR_MISMATCH, ) def cman_udpu_restart_required(): """ warn user it is required to restart CMAN cluster for changes to take effect """ return ReportItem.warning( report_codes.CMAN_UDPU_RESTART_REQUIRED, ) def cman_broadcast_all_rings(): """ broadcast enabled in all rings, CMAN doesn't support 1 ring only broadcast """ return ReportItem.warning( report_codes.CMAN_BROADCAST_ALL_RINGS, ) def service_start_started(service, instance=None): """ system service is being started string service service name or description string instance instance of service """ return ReportItem.info( report_codes.SERVICE_START_STARTED, info={ "service": service, "instance": instance, } ) def service_start_error(service, reason, node=None, instance=None): """ system service start failed string service service name or description string reason error message string node node on which service has been requested to start string instance instance of service """ return ReportItem.error( report_codes.SERVICE_START_ERROR, info={ "service": service, "reason": reason, "node": node, "instance": instance, } ) def service_start_success(service, node=None, instance=None): """ system service was started successfully string service service name or description string node node on which service has been requested to start string instance instance of service """ return ReportItem.info( report_codes.SERVICE_START_SUCCESS, info={ "service": service, "node": node, "instance": instance, } ) def service_start_skipped(service, reason, node=None, instance=None): """ starting system service was skipped, no error occured string service service name or description string reason why the start has been skipped string node node on which service has been requested to start string instance instance of service """ return ReportItem.info( report_codes.SERVICE_START_SKIPPED, info={ "service": service, "reason": reason, "node": node, "instance": instance, } ) def service_stop_started(service, instance=None): """ system service is being stopped string service service name or description string instance instance of service """ return ReportItem.info( report_codes.SERVICE_STOP_STARTED, info={ "service": service, "instance": instance, } ) def service_stop_error(service, reason, node=None, instance=None): """ system service stop failed string service service name or description string reason error message string node node on which service has been requested to stop string instance instance of service """ return ReportItem.error( report_codes.SERVICE_STOP_ERROR, info={ "service": service, "reason": reason, "node": node, "instance": instance, } ) def service_stop_success(service, node=None, instance=None): """ system service was stopped successfully string service service name or description string node node on which service has been requested to stop string instance instance of service """ return ReportItem.info( report_codes.SERVICE_STOP_SUCCESS, info={ "service": service, "node": node, "instance": instance, } ) def service_kill_error(services, reason): """ system services kill failed iterable services services name or description string reason error message """ return ReportItem.error( report_codes.SERVICE_KILL_ERROR, info={ "services": services, "reason": reason, } ) def service_kill_success(services): """ system services were killed successfully iterable services services name or description """ return ReportItem.info( report_codes.SERVICE_KILL_SUCCESS, info={ "services": services, } ) def service_enable_started(service, instance=None): """ system service is being enabled string service service name or description string instance instance of service """ return ReportItem.info( report_codes.SERVICE_ENABLE_STARTED, info={ "service": service, "instance": instance, } ) def service_enable_error(service, reason, node=None, instance=None): """ system service enable failed string service service name or description string reason error message string node node on which service was enabled string instance instance of service """ return ReportItem.error( report_codes.SERVICE_ENABLE_ERROR, info={ "service": service, "reason": reason, "node": node, "instance": instance, } ) def service_enable_success(service, node=None, instance=None): """ system service was enabled successfully string service service name or description string node node on which service has been enabled string instance instance of service """ return ReportItem.info( report_codes.SERVICE_ENABLE_SUCCESS, info={ "service": service, "node": node, "instance": instance, } ) def service_enable_skipped(service, reason, node=None, instance=None): """ enabling system service was skipped, no error occured string service service name or description string reason why the enabling has been skipped string node node on which service has been requested to enable string instance instance of service """ return ReportItem.info( report_codes.SERVICE_ENABLE_SKIPPED, info={ "service": service, "reason": reason, "node": node, "instance": instance } ) def service_disable_started(service, instance=None): """ system service is being disabled string service service name or description string instance instance of service """ return ReportItem.info( report_codes.SERVICE_DISABLE_STARTED, info={ "service": service, "instance": instance, } ) def service_disable_error(service, reason, node=None, instance=None): """ system service disable failed string service service name or description string reason error message string node node on which service was disabled string instance instance of service """ return ReportItem.error( report_codes.SERVICE_DISABLE_ERROR, info={ "service": service, "reason": reason, "node": node, "instance": instance, } ) def service_disable_success(service, node=None, instance=None): """ system service was disabled successfully string service service name or description string node node on which service was disabled string instance instance of service """ return ReportItem.info( report_codes.SERVICE_DISABLE_SUCCESS, info={ "service": service, "node": node, "instance": instance, } ) def unable_to_get_agent_metadata( agent, reason, severity=ReportItemSeverity.ERROR, forceable=None ): """ There were some issues trying to get metadata of agent string agent agent which metadata were unable to obtain string reason reason of failure """ return ReportItem( report_codes.UNABLE_TO_GET_AGENT_METADATA, severity, info={ "agent": agent, "reason": reason }, forceable=forceable ) def invalid_resource_agent_name(name): """ The entered resource agent name is not valid. This name has the internal structure. The code needs to work with parts of this structure and fails if parts can not be obtained. string name is entered name """ return ReportItem.error( report_codes.INVALID_RESOURCE_AGENT_NAME, info={ "name": name, } ) def agent_name_guessed(entered_name, guessed_name): """ Resource agent name was deduced from the entered name. Pcs supports the using of abbreviated resource agent name (e.g. ocf:heartbeat:Delay => Delay) when it can be clearly deduced. string entered_name is entered name string guessed_name is deduced name """ return ReportItem.info( report_codes.AGENT_NAME_GUESSED, info={ "entered_name": entered_name, "guessed_name": guessed_name, } ) def agent_name_guess_found_more_than_one(agent, possible_agents): """ More than one agents found based on the search string, specify one of them string agent searched name of an agent iterable possible_agents full names of agents matching the search """ return ReportItem.error( report_codes.AGENT_NAME_GUESS_FOUND_MORE_THAN_ONE, info={ "agent": agent, "possible_agents": possible_agents, "possible_agents_str": ", ".join(sorted(possible_agents)), } ) def agent_name_guess_found_none(agent): """ Specified agent doesn't exist string agent name of the agent which doesn't exist """ return ReportItem.error( report_codes.AGENT_NAME_GUESS_FOUND_NONE, info={"agent": agent} ) def omitting_node(node): """ warning that specified node will be omitted in following actions node -- node name """ return ReportItem.warning( report_codes.OMITTING_NODE, info={"node": node} ) def sbd_check_started(): """ info that SBD pre-enabling checks started """ return ReportItem.info( report_codes.SBD_CHECK_STARTED, ) def sbd_check_success(node): """ info that SBD pre-enabling check finished without issues on specified node node -- node name """ return ReportItem.info( report_codes.SBD_CHECK_SUCCESS, info={"node": node} ) def sbd_config_distribution_started(): """ distribution of SBD configuration started """ return ReportItem.info( report_codes.SBD_CONFIG_DISTRIBUTION_STARTED, ) def sbd_config_accepted_by_node(node): """ info that SBD configuration has been saved successfully on specified node node -- node name """ return ReportItem.info( report_codes.SBD_CONFIG_ACCEPTED_BY_NODE, info={"node": node} ) def unable_to_get_sbd_config(node, reason, severity=ReportItemSeverity.ERROR): """ unable to get SBD config from specified node (communication or parsing error) node -- node name reason -- reason of failure """ return ReportItem( report_codes.UNABLE_TO_GET_SBD_CONFIG, severity, info={ "node": node, "reason": reason } ) def sbd_enabling_started(): """ enabling SBD service started """ return ReportItem.info( report_codes.SBD_ENABLING_STARTED, ) def sbd_disabling_started(): """ disabling SBD service started """ return ReportItem.info( report_codes.SBD_DISABLING_STARTED, ) def invalid_response_format(node): """ error message that response in invalid format has been received from specified node node -- node name """ return ReportItem.error( report_codes.INVALID_RESPONSE_FORMAT, info={"node": node} ) def sbd_not_installed(node): """ sbd is not installed on specified node node -- node name """ return ReportItem.error( report_codes.SBD_NOT_INSTALLED, info={"node": node} ) def watchdog_not_found(node, watchdog): """ watchdog doesn't exist on specified node node -- node name watchdog -- watchdog device path """ return ReportItem.error( report_codes.WATCHDOG_NOT_FOUND, info={ "node": node, "watchdog": watchdog } ) def invalid_watchdog_path(watchdog): """ watchdog path is not absolut path watchdog -- watchdog device path """ return ReportItem.error( report_codes.WATCHDOG_INVALID, info={"watchdog": watchdog} ) def unable_to_get_sbd_status(node, reason): """ there was (communication or parsing) failure during obtaining status of SBD from specified node node -- node name reason -- reason of failure """ return ReportItem.warning( report_codes.UNABLE_TO_GET_SBD_STATUS, info={ "node": node, "reason": reason } ) def cluster_restart_required_to_apply_changes(): """ warn user a cluster needs to be manually restarted to use new configuration """ return ReportItem.warning( report_codes.CLUSTER_RESTART_REQUIRED_TO_APPLY_CHANGES, ) def cib_alert_recipient_already_exists( alert_id, recipient_value, severity=ReportItemSeverity.ERROR, forceable=None ): """ Recipient with specified value already exists in alert with id 'alert_id' alert_id -- id of alert to which recipient belongs recipient_value -- value of recipient """ return ReportItem( report_codes.CIB_ALERT_RECIPIENT_ALREADY_EXISTS, severity, info={ "recipient": recipient_value, "alert": alert_id }, forceable=forceable ) def cib_alert_recipient_invalid_value(recipient_value): """ Invalid recipient value. recipient_value -- recipient value """ return ReportItem.error( report_codes.CIB_ALERT_RECIPIENT_VALUE_INVALID, info={"recipient": recipient_value} ) def cib_alert_not_found(alert_id): """ Alert with specified id doesn't exist. alert_id -- id of alert """ return ReportItem.error( report_codes.CIB_ALERT_NOT_FOUND, info={"alert": alert_id} ) def cib_upgrade_successful(): """ Upgrade of CIB schema was successful. """ return ReportItem.info( report_codes.CIB_UPGRADE_SUCCESSFUL, ) def cib_upgrade_failed(reason): """ Upgrade of CIB schema failed. reason -- reason of failure """ return ReportItem.error( report_codes.CIB_UPGRADE_FAILED, info={"reason": reason} ) def unable_to_upgrade_cib_to_required_version( current_version, required_version ): """ Unable to upgrade CIB to minimal required schema version. current_version -- current version of CIB schema required_version -- required version of CIB schema """ return ReportItem.error( report_codes.CIB_UPGRADE_FAILED_TO_MINIMAL_REQUIRED_VERSION, info={ "required_version": "{0}.{1}.{2}".format(*required_version), "current_version": "{0}.{1}.{2}".format(*current_version) } ) def file_already_exists( file_role, file_path, severity=ReportItemSeverity.ERROR, forceable=None, node=None ): return ReportItem( report_codes.FILE_ALREADY_EXISTS, severity, info={ "file_role": file_role, "file_path": file_path, "node": node, }, forceable=forceable, ) def file_does_not_exist(file_role, file_path=""): return ReportItem.error( report_codes.FILE_DOES_NOT_EXIST, info={ "file_role": file_role, "file_path": file_path, }, ) def file_io_error( file_role, file_path="", reason="", operation="work with", severity=ReportItemSeverity.ERROR ): return ReportItem( report_codes.FILE_IO_ERROR, severity, info={ "file_role": file_role, "file_path": file_path, "reason": reason, "operation": operation }, ) def unable_to_determine_user_uid(user): return ReportItem.error( report_codes.UNABLE_TO_DETERMINE_USER_UID, info={ "user": user } ) def unable_to_determine_group_gid(group): return ReportItem.error( report_codes.UNABLE_TO_DETERMINE_GROUP_GID, info={ "group": group } ) def unsupported_operation_on_non_systemd_systems(): return ReportItem.error( report_codes.UNSUPPORTED_OPERATION_ON_NON_SYSTEMD_SYSTEMS, ) def live_environment_required(forbidden_options): return ReportItem.error( report_codes.LIVE_ENVIRONMENT_REQUIRED, info={ "forbidden_options": forbidden_options, } ) def quorum_cannot_disable_atb_due_to_sbd( severity=ReportItemSeverity.ERROR, forceable=None ): """ Quorum option auto_tie_breaker cannot be disbled due to SBD. """ return ReportItem( report_codes.COROSYNC_QUORUM_CANNOT_DISABLE_ATB_DUE_TO_SBD, severity, forceable=forceable ) def sbd_requires_atb(): """ Warning that ATB will be enabled in order to make SBD fencing effective. """ return ReportItem.warning( report_codes.SBD_REQUIRES_ATB, ) def acl_role_is_already_assigned_to_target(role_id, target_id): """ Error that ACL target or group has already assigned role. """ return ReportItem.error( report_codes.CIB_ACL_ROLE_IS_ALREADY_ASSIGNED_TO_TARGET, info={ "role_id": role_id, "target_id": target_id, } ) def acl_role_is_not_assigned_to_target(role_id, target_id): """ Error that acl role is not assigned to target or group """ return ReportItem.error( report_codes.CIB_ACL_ROLE_IS_NOT_ASSIGNED_TO_TARGET, info={ "role_id": role_id, "target_id": target_id, } ) def acl_target_already_exists(target_id): """ Error that target with specified id aleready axists in configuration. """ return ReportItem.error( report_codes.CIB_ACL_TARGET_ALREADY_EXISTS, info={ "target_id": target_id, } ) def cluster_conf_invalid_format(reason): """ cluster.conf parsing error """ return ReportItem.error( report_codes.CLUSTER_CONF_LOAD_ERROR_INVALID_FORMAT, info={ "reason": reason, } ) def cluster_conf_read_error(path, reason): """ Unable to read cluster.conf """ return ReportItem.error( report_codes.CLUSTER_CONF_READ_ERROR, info={ "path": path, "reason": reason, } ) pcs-0.9.155/pcs/lib/resource_agent.py000066400000000000000000000472371301012375000173770ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import os import re from lxml import etree from pcs import settings from pcs.lib import reports from pcs.lib.errors import LibraryError, ReportItemSeverity from pcs.lib.pacemaker_values import is_true from pcs.common import report_codes _crm_resource = os.path.join(settings.pacemaker_binaries, "crm_resource") class ResourceAgentError(Exception): # pylint: disable=super-init-not-called def __init__(self, agent, message=""): self.agent = agent self.message = message class UnableToGetAgentMetadata(ResourceAgentError): pass class InvalidResourceAgentName(ResourceAgentError): pass def list_resource_agents_standards(runner): """ Return list of resource agents standards (ocf, lsb, ... ) on the local host CommandRunner runner """ # retval is number of standards found stdout, dummy_stderr, dummy_retval = runner.run([ _crm_resource, "--list-standards" ]) ignored_standards = frozenset([ # we are only interested in RESOURCE agents "stonith", ]) return _prepare_agent_list(stdout, ignored_standards) def list_resource_agents_ocf_providers(runner): """ Return list of resource agents ocf providers on the local host CommandRunner runner """ # retval is number of providers found stdout, dummy_stderr, dummy_retval = runner.run([ _crm_resource, "--list-ocf-providers" ]) return _prepare_agent_list(stdout) def list_resource_agents_standards_and_providers(runner): """ Return list of all standard[:provider] on the local host CommandRunner runner """ standards = ( list_resource_agents_standards(runner) + [ "ocf:{0}".format(provider) for provider in list_resource_agents_ocf_providers(runner) ] ) # do not list ocf resources twice try: standards.remove("ocf") except ValueError: pass return sorted( standards, # works with both str and unicode in both python 2 and 3 key=lambda x: x.lower() ) def list_resource_agents(runner, standard_provider): """ Return list of resource agents for specified standard on the local host CommandRunner runner string standard_provider standard[:provider], e.g. lsb, ocf, ocf:pacemaker """ # retval is 0 on success, anything else when no agents found stdout, dummy_stderr, retval = runner.run([ _crm_resource, "--list-agents", standard_provider ]) if retval != 0: return [] return _prepare_agent_list(stdout) def list_stonith_agents(runner): """ Return list of fence agents on the local host CommandRunner runner """ # retval is 0 on success, anything else when no agents found stdout, dummy_stderr, retval = runner.run([ _crm_resource, "--list-agents", "stonith" ]) if retval != 0: return [] ignored_agents = frozenset([ "fence_ack_manual", "fence_check", "fence_kdump_send", "fence_legacy", "fence_na", "fence_node", "fence_nss_wrapper", "fence_pcmk", "fence_sanlockd", "fence_tool", "fence_virtd", "fence_vmware_helper", ]) return _prepare_agent_list(stdout, ignored_agents) def _prepare_agent_list(agents_string, filter_list=None): ignored = frozenset(filter_list) if filter_list else frozenset([]) result = [ name for name in [line.strip() for line in agents_string.splitlines()] if name and name not in ignored ] return sorted( result, # works with both str and unicode in both python 2 and 3 key=lambda x: x.lower() ) def guess_resource_agent_full_name(runner, search_agent_name): """ List resource agents matching specified search term string search_agent_name part of full agent name """ search_lower = search_agent_name.lower() # list all possible names possible_names = [] for std in list_resource_agents_standards_and_providers(runner): for agent in list_resource_agents(runner, std): if search_lower == agent.lower(): possible_names.append("{0}:{1}".format(std, agent)) # construct agent wrappers agent_candidates = [ ResourceAgent(runner, agent) for agent in possible_names ] # check if the agent is valid return [ agent for agent in agent_candidates if agent.is_valid_metadata() ] def guess_exactly_one_resource_agent_full_name(runner, search_agent_name): """ Get one resource agent matching specified search term string search_agent_name last part of full agent name Raise LibraryError if zero or more than one agents found """ agents = guess_resource_agent_full_name(runner, search_agent_name) if not agents: raise LibraryError( reports.agent_name_guess_found_none(search_agent_name) ) if len(agents) > 1: raise LibraryError( reports.agent_name_guess_found_more_than_one( search_agent_name, [agent.get_name() for agent in agents] ) ) return agents[0] def find_valid_resource_agent_by_name( report_processor, runner, name, allowed_absent=False ): if ":" not in name: agent = guess_exactly_one_resource_agent_full_name(runner, name) report_processor.process( reports.agent_name_guessed(name, agent.get_name()) ) return agent try: return ResourceAgent(runner, name).validate_metadata() except InvalidResourceAgentName as e: raise LibraryError(resource_agent_error_to_report_item(e)) except UnableToGetAgentMetadata as e: if not allowed_absent: raise LibraryError(resource_agent_error_to_report_item(e)) report_processor.process(resource_agent_error_to_report_item( e, severity=ReportItemSeverity.WARNING, forceable=True )) return AbsentResourceAgent(runner, name) class Agent(object): """ Base class for providing convinient access to an agent's metadata """ def __init__(self, runner): """ create an instance which reads metadata by itself on demand CommandRunner runner """ self._runner = runner self._metadata = None def get_name(self): raise NotImplementedError() def get_name_info(self): """ Get structured agent's info, only name is populated """ return { "name": self.get_name(), "shortdesc":"", "longdesc": "", "parameters": [], "actions": [], } def get_description_info(self): """ Get structured agent's info, only name and description is populated """ agent_info = self.get_name_info() agent_info["shortdesc"] = self.get_shortdesc() agent_info["longdesc"] = self.get_longdesc() return agent_info def get_full_info(self): """ Get structured agent's info, all items are populated """ agent_info = self.get_description_info() agent_info["parameters"] = self.get_parameters() agent_info["actions"] = self.get_actions() return agent_info def get_shortdesc(self): """ Get a short description of agent's purpose """ return ( self._get_text_from_dom_element( self._get_metadata().find("shortdesc") ) or self._get_metadata().get("shortdesc", "") ) def get_longdesc(self): """ Get a long description of agent's purpose """ return self._get_text_from_dom_element( self._get_metadata().find("longdesc") ) def get_parameters(self): """ Get list of agent's parameters, each parameter is described by dict: { name: name of parameter longdesc: long description, shortdesc: short description, type: data type od parameter, default: default value, required: True if is required parameter, False otherwise } """ params_element = self._get_metadata().find("parameters") if params_element is None: return [] return [ self._get_parameter(parameter) for parameter in params_element.iter("parameter") ] def _get_parameter(self, parameter_element): value_type = "string" default_value = None content_element = parameter_element.find("content") if content_element is not None: value_type = content_element.get("type", value_type) default_value = content_element.get("default", default_value) return { "name": parameter_element.get("name", ""), "longdesc": self._get_text_from_dom_element( parameter_element.find("longdesc") ), "shortdesc": self._get_text_from_dom_element( parameter_element.find("shortdesc") ), "type": value_type, "default": default_value, "required": is_true(parameter_element.get("required", "0")), "advanced": False, } def validate_parameters_values(self, parameters_values): """ Return tuple of lists (, ) dict parameters_values key is attribute name and value is attribute value """ # TODO Add value and type checking (e.g. if parameter["type"] is # integer, its value cannot be "abc"). This most probably will require # redefining the format of the return value and rewriting the whole # function, which will only be good. For now we just stick to the # original legacy code. agent_params = self.get_parameters() required_missing = [] for attr in agent_params: if attr["required"] and attr["name"] not in parameters_values: required_missing.append(attr["name"]) valid_attrs = [attr["name"] for attr in agent_params] return ( [attr for attr in parameters_values if attr not in valid_attrs], required_missing ) def get_actions(self): """ Get list of agent's actions (operations) """ actions_element = self._get_metadata().find("actions") if actions_element is None: return [] # TODO Resulting dict should contain all keys defined for an action. # But we do not know what are those, because the metadata xml schema is # outdated and doesn't describe current agents' metadata xml. return [ dict(action.items()) for action in actions_element.iter("action") ] def _get_metadata(self): """ Return metadata DOM Raise UnableToGetAgentMetadata if agent doesn't exist or unable to get or parse its metadata """ if self._metadata is None: self._metadata = self._parse_metadata(self._load_metadata()) return self._metadata def _load_metadata(self): raise NotImplementedError() def _parse_metadata(self, metadata): try: dom = etree.fromstring(metadata) # TODO Majority of agents don't provide valid metadata, so we skip # the validation for now. We want to enable it once the schema # and/or agents are fixed. # When enabling this check for overrides in child classes. #if os.path.isfile(settings.agent_metadata_schema): # etree.DTD(file=settings.agent_metadata_schema).assertValid(dom) return dom except (etree.XMLSyntaxError, etree.DocumentInvalid) as e: raise UnableToGetAgentMetadata(self.get_name(), str(e)) def _get_text_from_dom_element(self, element): if element is None or element.text is None: return "" return element.text.strip() class FakeAgentMetadata(Agent): def get_name(self): raise NotImplementedError() def _load_metadata(self): raise NotImplementedError() class StonithdMetadata(FakeAgentMetadata): def get_name(self): return "stonithd" def _get_parameter(self, parameter_element): parameter = super(StonithdMetadata, self)._get_parameter( parameter_element ) # Metadata are written in such a way that a longdesc text is a # continuation of a shortdesc text. parameter["longdesc"] = "{0}\n{1}".format( parameter["shortdesc"], parameter["longdesc"] ).strip() parameter["advanced"] = parameter["shortdesc"].startswith( "Advanced use only" ) return parameter def _load_metadata(self): stdout, stderr, dummy_retval = self._runner.run( [settings.stonithd_binary, "metadata"] ) metadata = stdout.strip() if not metadata: raise UnableToGetAgentMetadata(self.get_name(), stderr.strip()) return metadata class CrmAgent(Agent): def __init__(self, runner, full_agent_name): """ init CommandRunner runner string full_agent_name standard:provider:type or standard:type """ super(CrmAgent, self).__init__(runner) self._full_agent_name = full_agent_name def get_name(self): return self._full_agent_name def is_valid_metadata(self): """ If we are able to get metadata, we consider the agent existing and valid """ # if the agent is valid, we do not need to load its metadata again try: self._get_metadata() except UnableToGetAgentMetadata: return False return True def validate_metadata(self): """ Validate metadata by attepmt to retrieve it. """ self._get_metadata() return self def _load_metadata(self): env_path = ":".join([ # otherwise pacemaker cannot run RHEL fence agents to get their # metadata settings.fence_agent_binaries, # otherwise heartbeat and cluster-glue agents don't work "/bin/", # otherwise heartbeat and cluster-glue agents don't work "/usr/bin/", ]) stdout, stderr, retval = self._runner.run( [_crm_resource, "--show-metadata", self._full_agent_name], env_extend={ "PATH": env_path, } ) if retval != 0: raise UnableToGetAgentMetadata(self.get_name(), stderr.strip()) return stdout.strip() class ResourceAgent(CrmAgent): """ Provides convinient access to a resource agent's metadata """ def __init__(self, runner, full_agent_name): if not re.match("^[^:]+(:[^:]+){1,2}$", full_agent_name): raise InvalidResourceAgentName(full_agent_name) super(ResourceAgent, self).__init__(runner, full_agent_name) class AbsentResourceAgent(ResourceAgent): def _load_metadata(self): return "" def validate_parameters_values(self, parameters_values): return ([], []) class StonithAgent(CrmAgent): """ Provides convinient access to a stonith agent's metadata """ _stonithd_metadata = None def __init__(self, runner, agent_name): super(StonithAgent, self).__init__( runner, "stonith:{0}".format(agent_name) ) self._agent_name = agent_name def get_name(self): return self._agent_name def get_parameters(self): return ( self._filter_parameters( super(StonithAgent, self).get_parameters() ) + self._get_stonithd_metadata().get_parameters() ) def _filter_parameters(self, parameters): """ Remove parameters that should not be available to the user. """ # We don't allow the user to change these options which are only # intended to be used interactively on command line. remove_parameters = frozenset([ "debug", "help", "verbose", "version", ]) filtered = [] for param in parameters: if param["name"] in remove_parameters: continue elif param["name"] == "action": # However we still need the user to be able to set 'action' due # to backward compatibility reasons. So we just mark it as not # required. new_param = dict(param) new_param["shortdesc"] = "\n".join(filter(None, [ param.get("shortdesc", ""), "WARNING: specifying 'action' is deprecated and not " "necessary with current Pacemaker versions." , ])) new_param["required"] = False filtered.append(new_param) else: filtered.append(param) # 'port' parameter is required by a fence agent, but it is filled # automatically by pacemaker based on 'pcmk_host_map' or # 'pcmk_host_list' parameter (defined in stonithd metadata). # Pacemaker marks the 'port' parameter as not required for us. return filtered def _get_stonithd_metadata(self): if not self.__class__._stonithd_metadata: self.__class__._stonithd_metadata = StonithdMetadata(self._runner) return self.__class__._stonithd_metadata def get_actions(self): # In previous versions of pcs there was no way to read actions from # stonith agents, the functions always returned an empty list. It # wasn't clear if that is a mistake or an intention. We keep it that # way for two reasons: # 1) Fence agents themselfs specify the actions without any attributes # (interval, timeout) # 2) Pacemaker explained shows an example stonith agent configuration # in CIB with only monitor operation specified (and that pcs creates # automatically in "pcs stonith create" regardless of provided actions # from here). # It may be better to return real actions from this class and deal ommit # them in higher layers, which can decide if the actions are desired or # not. For now there is not enough information to do that. Code which # uses this is not clean enough. Once everything is cleaned we should # decide if it is better to move this to higher level. return [] def get_provides_unfencing(self): # self.get_actions returns an empty list for action in super(StonithAgent, self).get_actions(): if ( action.get("name", "") == "on" and action.get("on_target", "0") == "1" and action.get("automatic", "0") == "1" ): return True return False def resource_agent_error_to_report_item( e, severity=ReportItemSeverity.ERROR, forceable=False ): """ Transform ResourceAgentError to ReportItem """ force = None if e.__class__ == UnableToGetAgentMetadata: if severity == ReportItemSeverity.ERROR and forceable: force = report_codes.FORCE_METADATA_ISSUE return reports.unable_to_get_agent_metadata( e.agent, e.message, severity, force ) if e.__class__ == InvalidResourceAgentName: return reports.invalid_resource_agent_name(e.agent) raise e pcs-0.9.155/pcs/lib/sbd.py000066400000000000000000000333241301012375000151320ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import json from pcs import settings from pcs.common import tools from pcs.lib import ( external, reports, ) from pcs.lib.tools import dict_to_environment_file from pcs.lib.external import ( NodeCommunicator, node_communicator_exception_to_report_item, NodeCommunicationException, ) from pcs.lib.errors import LibraryError def _run_parallel_and_raise_lib_error_on_failure(func, param_list): """ Run function func in parallel for all specified parameters in arg_list. Raise LibraryError on any failure. func -- function to be run param_list -- list of tuples: (*args, **kwargs) """ report_list = [] def _parallel(*args, **kwargs): try: func(*args, **kwargs) except NodeCommunicationException as e: report_list.append(node_communicator_exception_to_report_item(e)) except LibraryError as e: report_list.extend(e.args) tools.run_parallel(_parallel, param_list) if report_list: raise LibraryError(*report_list) def _even_number_of_nodes_and_no_qdevice( corosync_conf_facade, node_number_modifier=0 ): """ Returns True whenever cluster has no quorum device configured and number of nodes + node_number_modifier is even number, False otherwise. corosync_conf_facade -- node_number_modifier -- this value will be added to current number of nodes. This can be useful to test whenever is ATB needed when adding/removing node. """ return ( not corosync_conf_facade.has_quorum_device() and (len(corosync_conf_facade.get_nodes()) + node_number_modifier) % 2 == 0 ) def is_auto_tie_breaker_needed( runner, corosync_conf_facade, node_number_modifier=0 ): """ Returns True whenever quorum option auto tie breaker is needed to be enabled for proper working of SBD fencing. False if it is not needed. runner -- command runner corosync_conf_facade -- node_number_modifier -- this value vill be added to current number of nodes. This can be useful to test whenever is ATB needed when adding/removeing node. """ return ( _even_number_of_nodes_and_no_qdevice( corosync_conf_facade, node_number_modifier ) and is_sbd_installed(runner) and is_sbd_enabled(runner) ) def atb_has_to_be_enabled_pre_enable_check(corosync_conf_facade): """ Returns True whenever quorum option auto_tie_breaker is needed to be enabled for proper working of SBD fencing. False if it is not needed. This function doesn't check if sbd is installed nor enabled. """ return ( not corosync_conf_facade.is_enabled_auto_tie_breaker() and _even_number_of_nodes_and_no_qdevice(corosync_conf_facade) ) def atb_has_to_be_enabled(runner, corosync_conf_facade, node_number_modifier=0): """ Return True whenever quorum option auto tie breaker has to be enabled for proper working of SBD fencing. False if it's not needed or it is already enabled. runner -- command runner corosync_conf_facade -- node_number_modifier -- this value vill be added to current number of nodes. This can be useful to test whenever is ATB needed when adding/removeing node. """ return ( not corosync_conf_facade.is_enabled_auto_tie_breaker() and is_auto_tie_breaker_needed( runner, corosync_conf_facade, node_number_modifier ) ) def check_sbd(communicator, node, watchdog): """ Check SBD on specified 'node' and existence of specified watchdog. communicator -- NodeCommunicator node -- NodeAddresses watchdog -- watchdog path """ return communicator.call_node( node, "remote/check_sbd", NodeCommunicator.format_data_dict([("watchdog", watchdog)]) ) def check_sbd_on_node(report_processor, node_communicator, node, watchdog): """ Check if SBD can be enabled on specified 'node'. Raises LibraryError if check fails. Raises NodeCommunicationException if there is communication issue. report_processor -- node_communicator -- NodeCommunicator node -- NodeAddresses watchdog -- watchdog path """ report_list = [] try: data = json.loads(check_sbd(node_communicator, node, watchdog)) if not data["sbd"]["installed"]: report_list.append(reports.sbd_not_installed(node.label)) if not data["watchdog"]["exist"]: report_list.append(reports.watchdog_not_found(node.label, watchdog)) except (ValueError, KeyError): raise LibraryError(reports.invalid_response_format(node.label)) if report_list: raise LibraryError(*report_list) report_processor.process(reports.sbd_check_success(node.label)) def check_sbd_on_all_nodes(report_processor, node_communicator, nodes_watchdog): """ Checks SBD (if SBD is installed and watchdog exists) on all NodeAddresses defined as keys in data. Raises LibraryError with all ReportItems in case of any failure. report_processor -- node_communicator -- NodeCommunicator nodes_watchdog -- dictionary with NodeAddresses as keys and watchdog path as value """ report_processor.process(reports.sbd_check_started()) _run_parallel_and_raise_lib_error_on_failure( check_sbd_on_node, [ ([report_processor, node_communicator, node, watchdog], {}) for node, watchdog in sorted(nodes_watchdog.items()) ] ) def set_sbd_config(communicator, node, config): """ Send SBD configuration to 'node'. communicator -- NodeCommunicator node -- NodeAddresses config -- string, SBD configuration file """ communicator.call_node( node, "remote/set_sbd_config", NodeCommunicator.format_data_dict([("config", config)]) ) def set_sbd_config_on_node( report_processor, node_communicator, node, config, watchdog ): """ Send SBD configuration to 'node' with specified watchdog set. Also puts correct node name into SBD_OPTS option (SBD_OPTS="-n "). report_processor -- node_communicator -- NodeCommunicator node -- NodeAddresses config -- dictionary in format: : watchdog -- path to watchdog device """ config = dict(config) config["SBD_OPTS"] = '"-n {node_name}"'.format(node_name=node.label) if watchdog: config["SBD_WATCHDOG_DEV"] = watchdog set_sbd_config(node_communicator, node, dict_to_environment_file(config)) report_processor.process( reports.sbd_config_accepted_by_node(node.label) ) def set_sbd_config_on_all_nodes( report_processor, node_communicator, node_list, config, watchdog_dict ): """ Send SBD configuration 'config' to all nodes in 'node_list'. Option SBD_OPTS="-n " is added automatically. Raises LibraryError with all ReportItems in case of any failure. report_processor -- node_communicator -- NodeCommunicator node_list -- NodeAddressesList config -- dictionary in format: : watchdog_dict -- dictionary of watchdogs where key is NodeAdresses object and value is path to watchdog """ report_processor.process(reports.sbd_config_distribution_started()) _run_parallel_and_raise_lib_error_on_failure( set_sbd_config_on_node, [ ( [ report_processor, node_communicator, node, config, watchdog_dict.get(node) ], {} ) for node in node_list ] ) def enable_sbd_service(communicator, node): """ Enable SBD service on 'node'. communicator -- NodeCommunicator node -- NodeAddresses """ communicator.call_node(node, "remote/sbd_enable", None) def enable_sbd_service_on_node(report_processor, node_communicator, node): """ Enable SBD service on 'node'. Returns list of ReportItem if there was any failure. Empty list otherwise. report_processor -- node_communicator -- NodeCommunicator node -- NodeAddresses """ enable_sbd_service(node_communicator, node) report_processor.process(reports.service_enable_success("sbd", node.label)) def enable_sbd_service_on_all_nodes( report_processor, node_communicator, node_list ): """ Enable SBD service on all nodes in 'node_list'. Raises LibraryError with all ReportItems in case of any failure. report_processor -- node_communicator -- NodeCommunicator node_list -- NodeAddressesList """ report_processor.process(reports.sbd_enabling_started()) _run_parallel_and_raise_lib_error_on_failure( enable_sbd_service_on_node, [ ([report_processor, node_communicator, node], {}) for node in node_list ] ) def disable_sbd_service(communicator, node): """ Disable SBD service on 'node'. communicator -- NodeCommunicator node -- NodeAddresses """ communicator.call_node(node, "remote/sbd_disable", None) def disable_sbd_service_on_node(report_processor, node_communicator, node): """ Disable SBD service on 'node'. report_processor -- node_communicator -- NodeCommunicator node -- NodeAddresses """ disable_sbd_service(node_communicator, node) report_processor.process(reports.service_disable_success("sbd", node.label)) def disable_sbd_service_on_all_nodes( report_processor, node_communicator, node_list ): """ Disable SBD service on all nodes in 'node_list'. Raises LibraryError with all ReportItems in case of any failure. report_processor -- node_communicator -- NodeCommunicator node_list -- NodeAddressesList """ report_processor.process(reports.sbd_disabling_started()) _run_parallel_and_raise_lib_error_on_failure( disable_sbd_service_on_node, [ ([report_processor, node_communicator, node], {}) for node in node_list ] ) def set_stonith_watchdog_timeout_to_zero(communicator, node): """ Set cluster property 'stonith-watchdog-timeout' to value '0' on 'node'. communicator -- NodeCommunicator node -- NodeAddresses """ communicator.call_node( node, "remote/set_stonith_watchdog_timeout_to_zero", None ) def set_stonith_watchdog_timeout_to_zero_on_all_nodes( node_communicator, node_list ): """ Sets cluster property 'stonith-watchdog-timeout' to value '0' an all nodes in 'node_list', even if cluster is not currently running on them (direct editing CIB file). Raises LibraryError with all ReportItems in case of any failure. node_communicator -- NodeCommunicator node_list -- NodeAddressesList """ report_list = [] for node in node_list: try: set_stonith_watchdog_timeout_to_zero(node_communicator, node) except NodeCommunicationException as e: report_list.append(node_communicator_exception_to_report_item(e)) if report_list: raise LibraryError(*report_list) def remove_stonith_watchdog_timeout(communicator, node): """ Remove cluster property 'stonith-watchdog-timeout' on 'node'. communicator -- NodeCommunicator node -- NodeAddresses """ communicator.call_node(node, "remote/remove_stonith_watchdog_timeout", None) def remove_stonith_watchdog_timeout_on_all_nodes(node_communicator, node_list): """ Removes cluster property 'stonith-watchdog-timeout' from all nodes in 'node_list', even if cluster is not currently running on them (direct editing CIB file). Raises LibraryError with all ReportItems in case of any failure. node_communicator -- NodeCommunicator node_list -- NodeAddressesList """ report_list = [] for node in node_list: try: remove_stonith_watchdog_timeout(node_communicator, node) except NodeCommunicationException as e: report_list.append(node_communicator_exception_to_report_item(e)) if report_list: raise LibraryError(*report_list) def get_default_sbd_config(): """ Returns default SBD configuration as dictionary. """ return { "SBD_DELAY_START": "no", "SBD_PACEMAKER": "yes", "SBD_STARTMODE": "clean", "SBD_WATCHDOG_DEV": settings.sbd_watchdog_default, "SBD_WATCHDOG_TIMEOUT": "5" } def get_local_sbd_config(): """ Get local SBD configuration. Returns SBD configuration file as string. Raises LibraryError on any failure. """ try: with open(settings.sbd_config, "r") as sbd_cfg: return sbd_cfg.read() except EnvironmentError as e: raise LibraryError(reports.unable_to_get_sbd_config( "local node", str(e) )) def get_sbd_config(communicator, node): """ Get SBD configuration from 'node'. Returns SBD configuration string. communicator -- NodeCommunicator node -- NodeAddresses """ return communicator.call_node(node, "remote/get_sbd_config", None) def get_sbd_service_name(): return "sbd" if external.is_systemctl() else "sbd_helper" def is_sbd_enabled(runner): """ Check if SBD service is enabled in local system. Return True if SBD service is enabled, False otherwise. runner -- CommandRunner """ return external.is_service_enabled(runner, get_sbd_service_name()) def is_sbd_installed(runner): """ Check if SBD service is installed in local system. Reurns True id SBD service is installed. False otherwise. runner -- CommandRunner """ return external.is_service_installed(runner, get_sbd_service_name()) pcs-0.9.155/pcs/lib/test/000077500000000000000000000000001301012375000147625ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/test/__init__.py000066400000000000000000000000001301012375000170610ustar00rootroot00000000000000pcs-0.9.155/pcs/lib/test/misc.py000066400000000000000000000007071301012375000162730ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) import logging from pcs.lib.env import LibraryEnvironment as Env from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.test.tools.pcs_unittest import mock def get_mocked_env(**kwargs): return Env( logger=mock.MagicMock(logging.Logger), report_processor=MockLibraryReportProcessor(), **kwargs ) pcs-0.9.155/pcs/lib/test/test_cluster_conf_facade.py000066400000000000000000000106421301012375000223470ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.test.tools.assertions import ( assert_raise_library_error, assert_xml_equal, ) from pcs.test.tools.misc import outdent from lxml import etree from pcs.common import report_codes from pcs.lib.errors import ReportItemSeverity as severity from pcs.lib import cluster_conf_facade as lib class FromStringTest(TestCase): def test_success(self): facade = lib.ClusterConfFacade.from_string("") self.assertTrue(isinstance(facade, lib.ClusterConfFacade)) assert_xml_equal("", etree.tostring(facade._config).decode()) def test_syntax_error(self): assert_raise_library_error( lambda: lib.ClusterConfFacade.from_string(""), ( severity.ERROR, report_codes.CLUSTER_CONF_LOAD_ERROR_INVALID_FORMAT, {} ) ) def test_invalid_document_error(self): assert_raise_library_error( lambda: lib.ClusterConfFacade.from_string("string"), ( severity.ERROR, report_codes.CLUSTER_CONF_LOAD_ERROR_INVALID_FORMAT, {} ) ) class GetClusterNameTest(TestCase): def test_success(self): cfg = etree.XML('') self.assertEqual( "cluster-name", lib.ClusterConfFacade(cfg).get_cluster_name() ) def test_no_name(self): cfg = etree.XML('') self.assertEqual("", lib.ClusterConfFacade(cfg).get_cluster_name()) def test_not_cluster_element(self): cfg = etree.XML('') self.assertEqual("", lib.ClusterConfFacade(cfg).get_cluster_name()) class GetNodesTest(TestCase): def assert_equal_nodelist(self, expected_nodes, real_nodelist): real_nodes = [ {"ring0": n.ring0, "ring1": n.ring1, "name": n.name, "id": n.id} for n in real_nodelist ] self.assertEqual(expected_nodes, real_nodes) def test_success(self): config = outdent(""" """) self.assert_equal_nodelist( [ { "ring0": "node1", "ring1": "node1-altname", "name": None, "id": "1", }, { "ring0": "node2", "ring1": None, "name": None, "id": "2", }, { "ring0": "node3", "ring1": None, "name": None, "id": "3", } ], lib.ClusterConfFacade(etree.XML(config)).get_nodes() ) def test_no_nodes(self): config = "" self.assert_equal_nodelist( [], lib.ClusterConfFacade(etree.XML(config)).get_nodes() ) def test_missing_info(self): config = outdent(""" """) self.assert_equal_nodelist( [ { "ring0": None, "ring1": None, "name": None, "id": "1", }, { "ring0": "node2", "ring1": None, "name": None, "id": None, }, { "ring0": None, "ring1": None, "name": None, "id": None, } ], lib.ClusterConfFacade(etree.XML(config)).get_nodes() ) pcs-0.9.155/pcs/lib/test/test_env_file.py000066400000000000000000000154521301012375000201710ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.common import report_codes from pcs.lib.env_file import RealFile, GhostFile from pcs.lib.errors import ReportItemSeverity as severities from pcs.test.tools.assertions import( assert_raise_library_error, assert_report_item_list_equal ) from pcs.test.tools.custom_mock import MockLibraryReportProcessor from pcs.test.tools.pcs_unittest import mock class GhostFileReadTest(TestCase): def test_raises_when_trying_read_nonexistent_file(self): assert_raise_library_error( lambda: GhostFile("some role", content=None).read(), ( severities.ERROR, report_codes.FILE_DOES_NOT_EXIST, { "file_role": "some role", } ), ) @mock.patch("pcs.lib.env_file.os.path.exists", return_value=True) class RealFileAssertNoConflictWithExistingTest(TestCase): def check(self, report_processor, can_overwrite_existing=False): real_file = RealFile("some role", "/etc/booth/some-name.conf") real_file.assert_no_conflict_with_existing( report_processor, can_overwrite_existing ) def test_success_when_config_not_exists(self, mock_exists): mock_exists.return_value = False report_processor=MockLibraryReportProcessor() self.check(report_processor) assert_report_item_list_equal(report_processor.report_item_list, []) def test_raises_when_config_exists_and_overwrite_not_allowed(self, mock_ex): assert_raise_library_error( lambda: self.check(MockLibraryReportProcessor()), ( severities.ERROR, report_codes.FILE_ALREADY_EXISTS, { "file_path": "/etc/booth/some-name.conf" }, report_codes.FORCE_FILE_OVERWRITE, ), ) def test_warn_when_config_exists_and_overwrite_allowed(self, mock_exists): report_processor=MockLibraryReportProcessor() self.check(report_processor, can_overwrite_existing=True) assert_report_item_list_equal(report_processor.report_item_list, [( severities.WARNING, report_codes.FILE_ALREADY_EXISTS, { "file_path": "/etc/booth/some-name.conf" }, )]) class RealFileWriteTest(TestCase): def test_success_write_content_to_path(self): mock_open = mock.mock_open() mock_file_operation = mock.Mock() with mock.patch("pcs.lib.env_file.open", mock_open, create=True): RealFile("some role", "/etc/booth/some-name.conf").write( "config content", file_operation=mock_file_operation ) mock_open.assert_called_once_with("/etc/booth/some-name.conf", "w") mock_open().write.assert_called_once_with("config content") mock_file_operation.assert_called_once_with( "/etc/booth/some-name.conf" ) def test_success_binary(self): mock_open = mock.mock_open() mock_file_operation = mock.Mock() with mock.patch("pcs.lib.env_file.open", mock_open, create=True): RealFile("some role", "/etc/booth/some-name.conf").write( "config content".encode("utf-8"), file_operation=mock_file_operation, is_binary=True ) mock_open.assert_called_once_with("/etc/booth/some-name.conf", "wb") mock_open().write.assert_called_once_with( "config content".encode("utf-8") ) mock_file_operation.assert_called_once_with( "/etc/booth/some-name.conf" ) def test_raises_when_could_not_write(self): assert_raise_library_error( lambda: RealFile("some role", "/no/existing/file.path").write(["content"]), ( severities.ERROR, report_codes.FILE_IO_ERROR, { "reason": "No such file or directory: '/no/existing/file.path'" , } ) ) class RealFileReadTest(TestCase): def test_success_read_content_from_file(self): mock_open = mock.mock_open() with mock.patch("pcs.lib.env_file.open", mock_open, create=True): mock_open().read.return_value = "test booth\nconfig" self.assertEqual( "test booth\nconfig", RealFile("some role", "/path/to.file").read() ) def test_raises_when_could_not_read(self): assert_raise_library_error( lambda: RealFile("some role", "/no/existing/file.path").read(), ( severities.ERROR, report_codes.FILE_IO_ERROR, { "reason": "No such file or directory: '/no/existing/file.path'" , } ) ) class RealFileRemoveTest(TestCase): @mock.patch("pcs.lib.env_file.os.remove") @mock.patch("pcs.lib.env_file.os.path.exists", return_value=True) def test_success_remove_file(self, _, mock_remove): RealFile("some role", "/path/to.file").remove() mock_remove.assert_called_once_with("/path/to.file") @mock.patch( "pcs.lib.env_file.os.remove", side_effect=EnvironmentError(1, "mock remove failed", "/path/to.file") ) @mock.patch("pcs.lib.env_file.os.path.exists", return_value=True) def test_raise_library_error_when_remove_failed(self, _, dummy): assert_raise_library_error( lambda: RealFile("some role", "/path/to.file").remove(), ( severities.ERROR, report_codes.FILE_IO_ERROR, { 'reason': "mock remove failed: '/path/to.file'", 'file_role': 'some role', 'file_path': '/path/to.file' } ) ) @mock.patch("pcs.lib.env_file.os.path.exists", return_value=False) def test_existence_is_required(self, _): assert_raise_library_error( lambda: RealFile("some role", "/path/to.file").remove(), ( severities.ERROR, report_codes.FILE_IO_ERROR, { 'reason': "File does not exist", 'file_role': 'some role', 'file_path': '/path/to.file' } ) ) @mock.patch("pcs.lib.env_file.os.path.exists", return_value=False) def test_noexistent_can_be_silenced(self, _): RealFile("some role", "/path/to.file").remove(silence_no_existence=True) pcs-0.9.155/pcs/lib/test/test_errors.py000066400000000000000000000007701301012375000177130ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.lib.errors import LibraryEnvError class LibraryEnvErrorTest(TestCase): def test_can_sign_solved_reports(self): e = LibraryEnvError("first", "second", "third") for report in e.args: if report == "second": e.sign_processed(report) self.assertEqual(["first", "third"], e.unprocessed) pcs-0.9.155/pcs/lib/test/test_pacemaker_values.py000066400000000000000000000203611301012375000217040ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from pcs.test.tools.pcs_unittest import TestCase from pcs.test.tools.assertions import assert_raise_library_error from pcs.common import report_codes from pcs.lib.errors import ReportItemSeverity as severity import pcs.lib.pacemaker_values as lib class BooleanTest(TestCase): def test_true_is_true(self): self.assertTrue(lib.is_true("true")) self.assertTrue(lib.is_true("tRue")) self.assertTrue(lib.is_true("on")) self.assertTrue(lib.is_true("ON")) self.assertTrue(lib.is_true("yes")) self.assertTrue(lib.is_true("yeS")) self.assertTrue(lib.is_true("y")) self.assertTrue(lib.is_true("Y")) self.assertTrue(lib.is_true("1")) def test_nontrue_is_not_true(self): self.assertFalse(lib.is_true("")) self.assertFalse(lib.is_true(" 1 ")) self.assertFalse(lib.is_true("a")) self.assertFalse(lib.is_true("2")) self.assertFalse(lib.is_true("10")) self.assertFalse(lib.is_true("yes please")) def test_true_is_boolean(self): self.assertTrue(lib.is_boolean("true")) self.assertTrue(lib.is_boolean("tRue")) self.assertTrue(lib.is_boolean("on")) self.assertTrue(lib.is_boolean("ON")) self.assertTrue(lib.is_boolean("yes")) self.assertTrue(lib.is_boolean("yeS")) self.assertTrue(lib.is_boolean("y")) self.assertTrue(lib.is_boolean("Y")) self.assertTrue(lib.is_boolean("1")) def test_false_is_boolean(self): self.assertTrue(lib.is_boolean("false")) self.assertTrue(lib.is_boolean("fAlse")) self.assertTrue(lib.is_boolean("off")) self.assertTrue(lib.is_boolean("oFf")) self.assertTrue(lib.is_boolean("no")) self.assertTrue(lib.is_boolean("nO")) self.assertTrue(lib.is_boolean("n")) self.assertTrue(lib.is_boolean("N")) self.assertTrue(lib.is_boolean("0")) def test_nonboolean_is_not_boolean(self): self.assertFalse(lib.is_boolean("")) self.assertFalse(lib.is_boolean("a")) self.assertFalse(lib.is_boolean("2")) self.assertFalse(lib.is_boolean("10")) self.assertFalse(lib.is_boolean("yes please")) self.assertFalse(lib.is_boolean(" y")) self.assertFalse(lib.is_boolean("n ")) self.assertFalse(lib.is_boolean("NO!")) class TimeoutTest(TestCase): def test_valid(self): self.assertEqual(10, lib.timeout_to_seconds("10")) self.assertEqual(10, lib.timeout_to_seconds("10s")) self.assertEqual(10, lib.timeout_to_seconds("10sec")) self.assertEqual(600, lib.timeout_to_seconds("10m")) self.assertEqual(600, lib.timeout_to_seconds("10min")) self.assertEqual(36000, lib.timeout_to_seconds("10h")) self.assertEqual(36000, lib.timeout_to_seconds("10hr")) def test_invalid(self): self.assertEqual(None, lib.timeout_to_seconds("1a1s")) self.assertEqual(None, lib.timeout_to_seconds("10mm")) self.assertEqual(None, lib.timeout_to_seconds("10mim")) self.assertEqual(None, lib.timeout_to_seconds("aaa")) self.assertEqual(None, lib.timeout_to_seconds("")) self.assertEqual("1a1s", lib.timeout_to_seconds("1a1s", True)) self.assertEqual("10mm", lib.timeout_to_seconds("10mm", True)) self.assertEqual("10mim", lib.timeout_to_seconds("10mim", True)) self.assertEqual("aaa", lib.timeout_to_seconds("aaa", True)) self.assertEqual("", lib.timeout_to_seconds("", True)) class ValidateIdTest(TestCase): def test_valid(self): self.assertEqual(None, lib.validate_id("dummy")) self.assertEqual(None, lib.validate_id("DUMMY")) self.assertEqual(None, lib.validate_id("dUmMy")) self.assertEqual(None, lib.validate_id("dummy0")) self.assertEqual(None, lib.validate_id("dum0my")) self.assertEqual(None, lib.validate_id("dummy-")) self.assertEqual(None, lib.validate_id("dum-my")) self.assertEqual(None, lib.validate_id("dummy.")) self.assertEqual(None, lib.validate_id("dum.my")) self.assertEqual(None, lib.validate_id("_dummy")) self.assertEqual(None, lib.validate_id("dummy_")) self.assertEqual(None, lib.validate_id("dum_my")) def test_invalid_empty(self): assert_raise_library_error( lambda: lib.validate_id("", "test id"), ( severity.ERROR, report_codes.EMPTY_ID, { "id": "", "id_description": "test id", } ) ) def test_invalid_first_character(self): desc = "test id" info = { "id": "", "id_description": desc, "invalid_character": "", "is_first_char": True, } report = (severity.ERROR, report_codes.INVALID_ID, info) info["id"] = "0" info["invalid_character"] = "0" assert_raise_library_error( lambda: lib.validate_id("0", desc), report ) info["id"] = "-" info["invalid_character"] = "-" assert_raise_library_error( lambda: lib.validate_id("-", desc), report ) info["id"] = "." info["invalid_character"] = "." assert_raise_library_error( lambda: lib.validate_id(".", desc), report ) info["id"] = ":" info["invalid_character"] = ":" assert_raise_library_error( lambda: lib.validate_id(":", desc), report ) info["id"] = "0dummy" info["invalid_character"] = "0" assert_raise_library_error( lambda: lib.validate_id("0dummy", desc), report ) info["id"] = "-dummy" info["invalid_character"] = "-" assert_raise_library_error( lambda: lib.validate_id("-dummy", desc), report ) info["id"] = ".dummy" info["invalid_character"] = "." assert_raise_library_error( lambda: lib.validate_id(".dummy", desc), report ) info["id"] = ":dummy" info["invalid_character"] = ":" assert_raise_library_error( lambda: lib.validate_id(":dummy", desc), report ) def test_invalid_character(self): desc = "test id" info = { "id": "", "id_description": desc, "invalid_character": "", "is_first_char": False, } report = (severity.ERROR, report_codes.INVALID_ID, info) info["id"] = "dum:my" info["invalid_character"] = ":" assert_raise_library_error( lambda: lib.validate_id("dum:my", desc), report ) info["id"] = "dummy:" info["invalid_character"] = ":" assert_raise_library_error( lambda: lib.validate_id("dummy:", desc), report ) info["id"] = "dum?my" info["invalid_character"] = "?" assert_raise_library_error( lambda: lib.validate_id("dum?my", desc), report ) info["id"] = "dummy?" info["invalid_character"] = "?" assert_raise_library_error( lambda: lib.validate_id("dummy?", desc), report ) class IsScoreValueTest(TestCase): def test_returns_true_for_number(self): self.assertTrue(lib.is_score_value("1")) def test_returns_true_for_minus_number(self): self.assertTrue(lib.is_score_value("-1")) def test_returns_true_for_plus_number(self): self.assertTrue(lib.is_score_value("+1")) def test_returns_true_for_infinity(self): self.assertTrue(lib.is_score_value("INFINITY")) def test_returns_true_for_minus_infinity(self): self.assertTrue(lib.is_score_value("-INFINITY")) def test_returns_true_for_plus_infinity(self): self.assertTrue(lib.is_score_value("+INFINITY")) def test_returns_false_for_nonumber_noinfinity(self): self.assertFalse(lib.is_score_value("something else")) def test_returns_false_for_multiple_operators(self): self.assertFalse(lib.is_score_value("++INFINITY")) pcs-0.9.155/pcs/lib/test/test_resource_agent.py000066400000000000000000001400401301012375000213770ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) from lxml import etree from functools import partial from pcs.test.tools.assertions import ( ExtendedAssertionsMixin, assert_raise_library_error, assert_xml_equal, ) from pcs.test.tools.misc import create_patcher from pcs.test.tools.pcs_unittest import TestCase, mock from pcs.test.tools.xml import XmlManipulation from pcs.common import report_codes from pcs.lib import resource_agent as lib_ra from pcs.lib.errors import ReportItemSeverity as severity, LibraryError from pcs.lib.external import CommandRunner patch_agent = create_patcher("pcs.lib.resource_agent") class ListResourceAgentsStandardsTest(TestCase): def test_success_and_filter_stonith_out(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) agents = [ "ocf", "lsb", "service", "systemd", "nagios", "stonith", ] # retval is number of providers found mock_runner.run.return_value = ( "\n".join(agents) + "\n", "", len(agents) ) self.assertEqual( lib_ra.list_resource_agents_standards(mock_runner), [ "lsb", "nagios", "ocf", "service", "systemd", ] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-standards" ]) def test_success_filter_whitespace(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) agents = [ "", "ocf", " lsb", "service ", "systemd", " nagios ", "", "stonith", "", ] # retval is number of providers found mock_runner.run.return_value = ( "\n".join(agents) + "\n", "", len(agents) ) self.assertEqual( lib_ra.list_resource_agents_standards(mock_runner), [ "lsb", "nagios", "ocf", "service", "systemd", ] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-standards" ]) def test_empty(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ("", "", 0) self.assertEqual( lib_ra.list_resource_agents_standards(mock_runner), [] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-standards" ]) def test_error(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ("lsb", "error", 1) self.assertEqual( lib_ra.list_resource_agents_standards(mock_runner), ["lsb"] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-standards" ]) class ListResourceAgentsOcfProvidersTest(TestCase): def test_success(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) providers = [ "heartbeat", "openstack", "pacemaker", "booth", ] # retval is number of providers found mock_runner.run.return_value = ( "\n".join(providers) + "\n", "", len(providers) ) self.assertEqual( lib_ra.list_resource_agents_ocf_providers(mock_runner), [ "booth", "heartbeat", "openstack", "pacemaker", ] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-ocf-providers" ]) def test_success_filter_whitespace(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) providers = [ "", "heartbeat", " openstack", "pacemaker ", " booth ", ] # retval is number of providers found mock_runner.run.return_value = ( "\n".join(providers) + "\n", "", len(providers) ) self.assertEqual( lib_ra.list_resource_agents_ocf_providers(mock_runner), [ "booth", "heartbeat", "openstack", "pacemaker", ] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-ocf-providers" ]) def test_empty(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ("", "", 0) self.assertEqual( lib_ra.list_resource_agents_ocf_providers(mock_runner), [] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-ocf-providers" ]) def test_error(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ("booth", "error", 1) self.assertEqual( lib_ra.list_resource_agents_ocf_providers(mock_runner), ["booth"] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-ocf-providers" ]) class ListResourceAgentsStandardsAndProvidersTest(TestCase): def test_success(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.side_effect = [ ( "\n".join([ "ocf", "lsb", "service", "systemd", "nagios", "stonith", "", ]), "", 0 ), ( "\n".join([ "heartbeat", "openstack", "pacemaker", "booth", "", ]), "", 0 ), ] self.assertEqual( lib_ra.list_resource_agents_standards_and_providers(mock_runner), [ "lsb", "nagios", "ocf:booth", "ocf:heartbeat", "ocf:openstack", "ocf:pacemaker", "service", "systemd", ] ) self.assertEqual(2, len(mock_runner.run.mock_calls)) mock_runner.run.assert_has_calls([ mock.call(["/usr/sbin/crm_resource", "--list-standards"]), mock.call(["/usr/sbin/crm_resource", "--list-ocf-providers"]), ]) class ListResourceAgentsTest(TestCase): def test_success_standard(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( "\n".join([ "docker", "Dummy", "dhcpd", "Dummy", "ethmonitor", "", ]), "", 0 ) self.assertEqual( lib_ra.list_resource_agents(mock_runner, "ocf"), [ "dhcpd", "docker", "Dummy", "Dummy", "ethmonitor", ] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-agents", "ocf" ]) def test_success_standard_provider(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( "\n".join([ "ping", "SystemHealth", "SysInfo", "HealthCPU", "Dummy", "", ]), "", 0 ) self.assertEqual( lib_ra.list_resource_agents(mock_runner, "ocf:pacemaker"), [ "Dummy", "HealthCPU", "ping", "SysInfo", "SystemHealth", ] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-agents", "ocf:pacemaker" ]) def test_bad_standard(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( "", "No agents found for standard=nonsense, provider=*", 1 ) self.assertEqual( lib_ra.list_resource_agents(mock_runner, "nonsense"), [] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-agents", "nonsense" ]) class ListStonithAgentsTest(TestCase): def test_success(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( "\n".join([ "fence_xvm", "fence_wti", "fence_vmware_soap", "fence_virt", "fence_scsi", "", ]), "", 0 ) self.assertEqual( lib_ra.list_stonith_agents(mock_runner), [ "fence_scsi", "fence_virt", "fence_vmware_soap", "fence_wti", "fence_xvm", ] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-agents", "stonith" ]) def test_no_agents(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( "", "No agents found for standard=stonith provider=*", 1 ) self.assertEqual( lib_ra.list_stonith_agents(mock_runner), [] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-agents", "stonith" ]) def test_filter_hidden_agents(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.return_value = ( "\n".join([ "fence_na", "fence_wti", "fence_scsi", "fence_vmware_helper", "fence_nss_wrapper", "fence_node", "fence_vmware_soap", "fence_virt", "fence_pcmk", "fence_sanlockd", "fence_xvm", "fence_ack_manual", "fence_legacy", "fence_check", "fence_tool", "fence_kdump_send", "fence_virtd", "", ]), "", 0 ) self.assertEqual( lib_ra.list_stonith_agents(mock_runner), [ "fence_scsi", "fence_virt", "fence_vmware_soap", "fence_wti", "fence_xvm", ] ) mock_runner.run.assert_called_once_with([ "/usr/sbin/crm_resource", "--list-agents", "stonith" ]) class GuessResourceAgentFullNameTest(TestCase): def setUp(self): self.mock_runner_side_effect = [ # list standards ("ocf\n", "", 0), # list providers ("heartbeat\npacemaker\n", "", 0), # list agents for standard-provider pairs ("Delay\nDummy\n", "", 0), ("Dummy\nStateful\n", "", 0), ] def test_one_agent_list(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.side_effect = ( self.mock_runner_side_effect + [ ("", "", 0) ] ) self.assertEqual( [ agent.get_name() for agent in lib_ra.guess_resource_agent_full_name(mock_runner, "delay") ], ["ocf:heartbeat:Delay"] ) def test_one_agent_exception(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.side_effect = ( self.mock_runner_side_effect + [ ("", "", 0), ] ) self.assertEqual( lib_ra.guess_exactly_one_resource_agent_full_name( mock_runner, "delay" ).get_name(), "ocf:heartbeat:Delay" ) def test_two_agents_list(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.side_effect = ( self.mock_runner_side_effect + [ ("", "", 0), ("", "", 0), ] ) self.assertEqual( [ agent.get_name() for agent in lib_ra.guess_resource_agent_full_name(mock_runner, "dummy") ], ["ocf:heartbeat:Dummy", "ocf:pacemaker:Dummy"] ) def test_two_agents_one_valid_list(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.side_effect = ( self.mock_runner_side_effect + [ ("", "", 0), ("invalid metadata", "", 0), ] ) self.assertEqual( [ agent.get_name() for agent in lib_ra.guess_resource_agent_full_name(mock_runner, "dummy") ], ["ocf:heartbeat:Dummy"] ) def test_two_agents_exception(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.side_effect = ( self.mock_runner_side_effect + [ ("", "", 0), ("", "", 0), ] ) assert_raise_library_error( lambda: lib_ra.guess_exactly_one_resource_agent_full_name( mock_runner, "dummy" ), ( severity.ERROR, report_codes.AGENT_NAME_GUESS_FOUND_MORE_THAN_ONE, { "agent": "dummy", "possible_agents": [ "ocf:heartbeat:Dummy", "ocf:pacemaker:Dummy" ], } ), ) def test_no_agents_list(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.side_effect = self.mock_runner_side_effect self.assertEqual( lib_ra.guess_resource_agent_full_name(mock_runner, "missing"), [] ) def test_no_agents_exception(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.side_effect = self.mock_runner_side_effect assert_raise_library_error( lambda: lib_ra.guess_exactly_one_resource_agent_full_name( mock_runner, "missing" ), ( severity.ERROR, report_codes.AGENT_NAME_GUESS_FOUND_NONE, { "agent": "missing", } ), ) def test_no_valids_agent_list(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) mock_runner.run.side_effect = ( self.mock_runner_side_effect + [ ("invalid metadata", "", 0), ] ) self.assertEqual( lib_ra.guess_resource_agent_full_name(mock_runner, "Delay"), [] ) @mock.patch.object(lib_ra.Agent, "_get_metadata") class AgentMetadataGetShortdescTest(TestCase): def setUp(self): self.agent = lib_ra.Agent( mock.MagicMock(spec_set=CommandRunner) ) def test_no_desc(self, mock_metadata): xml = '' mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_shortdesc(), "" ) def test_shortdesc_attribute(self, mock_metadata): xml = '' mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_shortdesc(), "short description" ) def test_shortdesc_element(self, mock_metadata): xml = """ short \n description """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_shortdesc(), "short \n description" ) @mock.patch.object(lib_ra.Agent, "_get_metadata") class AgentMetadataGetLongdescTest(TestCase): def setUp(self): self.agent = lib_ra.Agent( mock.MagicMock(spec_set=CommandRunner) ) def test_no_desc(self, mock_metadata): xml = '' mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_longdesc(), "" ) def test_longesc_element(self, mock_metadata): xml = """ long \n description """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_longdesc(), "long \n description" ) @mock.patch.object(lib_ra.Agent, "_get_metadata") class AgentMetadataGetParametersTest(TestCase): def setUp(self): self.agent = lib_ra.Agent( mock.MagicMock(spec_set=CommandRunner) ) def test_no_parameters(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_parameters(), [] ) def test_empty_parameters(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_parameters(), [] ) def test_empty_parameter(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_parameters(), [ { "name": "", "longdesc": "", "shortdesc": "", "type": "string", "required": False, "default": None, "advanced": False, } ] ) def test_all_data_and_minimal_data(self, mock_metadata): xml = """ Long description short description """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_parameters(), [ { "name": "test_param", "longdesc": "Long description", "shortdesc": "short description", "type": "test_type", "required": True, "default": "default_value", "advanced": False, }, { "name": "another parameter", "longdesc": "", "shortdesc": "", "type": "string", "required": False, "default": None, "advanced": False, } ] ) @mock.patch.object(lib_ra.Agent, "_get_metadata") class AgentMetadataGetActionsTest(TestCase): def setUp(self): self.agent = lib_ra.Agent( mock.MagicMock(spec_set=CommandRunner) ) def test_no_actions(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_actions(), [] ) def test_empty_actions(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_actions(), [] ) def test_empty_action(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_actions(), [{}] ) def test_more_actions(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_actions(), [ { "name": "on", "automatic": "0" }, {"name": "off"}, {"name": "reboot"}, {"name": "status"} ] ) @mock.patch.object(lib_ra.Agent, "_get_metadata") @mock.patch.object(lib_ra.Agent, "get_name", lambda self: "agent-name") class AgentMetadataGetInfoTest(TestCase): def setUp(self): self.agent = lib_ra.Agent( mock.MagicMock(spec_set=CommandRunner) ) self.metadata = etree.XML(""" short description long description Long description short description """) def test_name_info(self, mock_metadata): mock_metadata.return_value = self.metadata self.assertEqual( self.agent.get_name_info(), { "name": "agent-name", "shortdesc": "", "longdesc": "", "parameters": [], "actions": [], } ) def test_description_info(self, mock_metadata): mock_metadata.return_value = self.metadata self.assertEqual( self.agent.get_description_info(), { "name": "agent-name", "shortdesc": "short description", "longdesc": "long description", "parameters": [], "actions": [], } ) def test_full_info(self, mock_metadata): mock_metadata.return_value = self.metadata self.assertEqual( self.agent.get_full_info(), { "name": "agent-name", "shortdesc": "short description", "longdesc": "long description", "parameters": [ { "name": "test_param", "longdesc": "Long description", "shortdesc": "short description", "type": "test_type", "required": True, "default": "default_value", "advanced": False, }, { "name": "another parameter", "longdesc": "", "shortdesc": "", "type": "string", "required": False, "default": None, "advanced": False, } ], "actions": [ { "name": "on", "automatic": "0" }, {"name": "off"}, ], } ) @mock.patch.object(lib_ra.Agent, "_get_metadata") class AgentMetadataValidateParametersValuesTest(TestCase): def setUp(self): self.agent = lib_ra.Agent( mock.MagicMock(spec_set=CommandRunner) ) self.metadata = etree.XML(""" Long description short description """) def test_all_required(self, mock_metadata): mock_metadata.return_value = self.metadata self.assertEqual( self.agent.validate_parameters_values({ "another_required_param": "value1", "required_param": "value2", }), ([], []) ) def test_all_required_and_optional(self, mock_metadata): mock_metadata.return_value = self.metadata self.assertEqual( self.agent.validate_parameters_values({ "another_required_param": "value1", "required_param": "value2", "test_param": "value3", }), ([], []) ) def test_all_required_and_invalid(self, mock_metadata): mock_metadata.return_value = self.metadata self.assertEqual( self.agent.validate_parameters_values({ "another_required_param": "value1", "required_param": "value2", "invalid_param": "value3", }), (["invalid_param"], []) ) def test_missing_required(self, mock_metadata): mock_metadata.return_value = self.metadata self.assertEqual( self.agent.validate_parameters_values({ }), ([], ["required_param", "another_required_param"]) ) def test_missing_required_and_invalid(self, mock_metadata): mock_metadata.return_value = self.metadata self.assertEqual( self.agent.validate_parameters_values({ "another_required_param": "value1", "invalid_param": "value3", }), (["invalid_param"], ["required_param"]) ) class StonithdMetadataGetMetadataTest(TestCase, ExtendedAssertionsMixin): def setUp(self): self.mock_runner = mock.MagicMock(spec_set=CommandRunner) self.agent = lib_ra.StonithdMetadata(self.mock_runner) def test_success(self): metadata = """ stonithd test metadata """ self.mock_runner.run.return_value = (metadata, "", 0) assert_xml_equal( str(XmlManipulation(self.agent._get_metadata())), metadata ) self.mock_runner.run.assert_called_once_with( ["/usr/libexec/pacemaker/stonithd", "metadata"] ) def test_failed_to_get_xml(self): self.mock_runner.run.return_value = ("", "some error", 1) self.assert_raises( lib_ra.UnableToGetAgentMetadata, self.agent._get_metadata, { "agent": "stonithd", "message": "some error", } ) self.mock_runner.run.assert_called_once_with( ["/usr/libexec/pacemaker/stonithd", "metadata"] ) def test_invalid_xml(self): self.mock_runner.run.return_value = ("some garbage", "", 0) self.assert_raises( lib_ra.UnableToGetAgentMetadata, self.agent._get_metadata, { "agent": "stonithd", "message": "Start tag expected, '<' not found, line 1, column 1", } ) self.mock_runner.run.assert_called_once_with( ["/usr/libexec/pacemaker/stonithd", "metadata"] ) @mock.patch.object(lib_ra.Agent, "_get_metadata") class StonithdMetadataGetParametersTest(TestCase): def setUp(self): self.agent = lib_ra.StonithdMetadata( mock.MagicMock(spec_set=CommandRunner) ) def test_success(self, mock_metadata): xml = """ Long description Advanced use only: short description """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_parameters(), [ { "name": "test_param", "longdesc": "Advanced use only: short description\nLong " "description", "shortdesc": "Advanced use only: short description", "type": "test_type", "required": False, "default": "default_value", "advanced": True }, { "name": "another parameter", "longdesc": "", "shortdesc": "", "type": "string", "required": False, "default": None, "advanced": False } ] ) class CrmAgentMetadataGetNameTest(TestCase, ExtendedAssertionsMixin): def test_success(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) agent_name = "ocf:pacemaker:Dummy" agent = lib_ra.CrmAgent(mock_runner, agent_name) self.assertEqual(agent.get_name(), agent_name) class CrmAgentMetadataGetMetadataTest(TestCase, ExtendedAssertionsMixin): def setUp(self): self.mock_runner = mock.MagicMock(spec_set=CommandRunner) self.agent_name = "ocf:pacemaker:Dummy" self.agent = lib_ra.CrmAgent(self.mock_runner, self.agent_name) def test_success(self): metadata = """ crm agent test metadata """ self.mock_runner.run.return_value = (metadata, "", 0) assert_xml_equal( str(XmlManipulation(self.agent._get_metadata())), metadata ) self.mock_runner.run.assert_called_once_with( ["/usr/sbin/crm_resource", "--show-metadata", self.agent_name], env_extend={ "PATH": "/usr/sbin/:/bin/:/usr/bin/", } ) def test_failed_to_get_xml(self): self.mock_runner.run.return_value = ("", "some error", 1) self.assert_raises( lib_ra.UnableToGetAgentMetadata, self.agent._get_metadata, { "agent": self.agent_name, "message": "some error", } ) self.mock_runner.run.assert_called_once_with( ["/usr/sbin/crm_resource", "--show-metadata", self.agent_name], env_extend={ "PATH": "/usr/sbin/:/bin/:/usr/bin/", } ) def test_invalid_xml(self): self.mock_runner.run.return_value = ("some garbage", "", 0) self.assert_raises( lib_ra.UnableToGetAgentMetadata, self.agent._get_metadata, { "agent": self.agent_name, "message": "Start tag expected, '<' not found, line 1, column 1", } ) self.mock_runner.run.assert_called_once_with( ["/usr/sbin/crm_resource", "--show-metadata", self.agent_name], env_extend={ "PATH": "/usr/sbin/:/bin/:/usr/bin/", } ) class CrmAgentMetadataIsValidAgentTest(TestCase): def setUp(self): self.mock_runner = mock.MagicMock(spec_set=CommandRunner) self.agent_name = "ocf:pacemaker:Dummy" self.agent = lib_ra.CrmAgent(self.mock_runner, self.agent_name) def test_success(self): metadata = """ crm agent test metadata """ self.mock_runner.run.return_value = (metadata, "", 0) self.assertTrue(self.agent.is_valid_metadata()) def test_fail(self): self.mock_runner.run.return_value = ("", "", 1) self.assertFalse(self.agent.is_valid_metadata()) class StonithAgentMetadataGetNameTest(TestCase, ExtendedAssertionsMixin): def test_success(self): mock_runner = mock.MagicMock(spec_set=CommandRunner) agent_name = "fence_dummy" agent = lib_ra.StonithAgent(mock_runner, agent_name) self.assertEqual(agent.get_name(), agent_name) class StonithAgentMetadataGetMetadataTest(TestCase, ExtendedAssertionsMixin): # Only test that correct name is going to crm_resource. Everything else is # covered by the parent class and therefore tested in its test. def setUp(self): self.mock_runner = mock.MagicMock(spec_set=CommandRunner) self.agent_name = "fence_dummy" self.agent = lib_ra.StonithAgent( self.mock_runner, self.agent_name ) def tearDown(self): lib_ra.StonithAgent._stonithd_metadata = None def test_success(self): metadata = """ crm agent test metadata """ self.mock_runner.run.return_value = (metadata, "", 0) assert_xml_equal( str(XmlManipulation(self.agent._get_metadata())), metadata ) self.mock_runner.run.assert_called_once_with( [ "/usr/sbin/crm_resource", "--show-metadata", "stonith:{0}".format(self.agent_name) ], env_extend={ "PATH": "/usr/sbin/:/bin/:/usr/bin/", } ) @mock.patch.object(lib_ra.Agent, "_get_metadata") class StonithAgentMetadataGetActionsTest(TestCase): def setUp(self): self.agent = lib_ra.StonithAgent( mock.MagicMock(spec_set=CommandRunner), "fence_dummy" ) def tearDown(self): lib_ra.StonithAgent._stonithd_metadata = None def test_more_actions(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertEqual( self.agent.get_actions(), [] ) class StonithAgentMetadataGetParametersTest(TestCase): def setUp(self): self.mock_runner = mock.MagicMock(spec_set=CommandRunner) self.agent_name = "fence_dummy" self.agent = lib_ra.StonithAgent( self.mock_runner, self.agent_name ) def tearDown(self): lib_ra.StonithAgent._stonithd_metadata = None def test_success(self): metadata = """ crm agent test metadata Fencing Action """ stonithd_metadata = """ """ self.mock_runner.run.side_effect = [ (metadata, "", 0), (stonithd_metadata, "", 0), ] self.assertEqual( self.agent.get_parameters(), [ { "name": "valid_param", "longdesc": "", "shortdesc": "", "type": "string", "required": False, "default": None, "advanced": False }, { "name": "action", "longdesc": "", "shortdesc": "Fencing Action\nWARNING: specifying 'action' is" " deprecated and not necessary with current Pacemaker" " versions." , "type": "string", "required": False, "default": None, "advanced": False }, { "name": "another_param", "longdesc": "", "shortdesc": "", "type": "string", "required": False, "default": None, "advanced": False }, { "name": "stonithd_param", "longdesc": "", "shortdesc": "", "type": "string", "required": False, "default": None, "advanced": False }, ] ) self.assertEqual(2, len(self.mock_runner.run.mock_calls)) self.mock_runner.run.assert_has_calls([ mock.call( [ "/usr/sbin/crm_resource", "--show-metadata", "stonith:{0}".format(self.agent_name) ], env_extend={ "PATH": "/usr/sbin/:/bin/:/usr/bin/", } ), mock.call( ["/usr/libexec/pacemaker/stonithd", "metadata"] ), ]) @mock.patch.object(lib_ra.Agent, "_get_metadata") class StonithAgentMetadataGetProvidesUnfencingTest(TestCase): def setUp(self): self.agent = lib_ra.StonithAgent( mock.MagicMock(spec_set=CommandRunner), "fence_dummy" ) def tearDown(self): lib_ra.StonithAgent._stonithd_metadata = None def test_true(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertTrue(self.agent.get_provides_unfencing()) def test_no_action_on(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertFalse(self.agent.get_provides_unfencing()) def test_no_tagret(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertFalse(self.agent.get_provides_unfencing()) def test_no_automatic(self, mock_metadata): xml = """ """ mock_metadata.return_value = etree.XML(xml) self.assertFalse(self.agent.get_provides_unfencing()) class ResourceAgentTest(TestCase): def test_raises_on_invalid_name(self): self.assertRaises( lib_ra.InvalidResourceAgentName, lambda: lib_ra.ResourceAgent(mock.MagicMock(), "invalid_name") ) def test_does_not_raise_on_valid_name(self): lib_ra.ResourceAgent(mock.MagicMock(), "formal:valid:name") class FindResourceAgentByNameTest(TestCase): def setUp(self): self.report_processor = mock.MagicMock() self.runner = mock.MagicMock() self.run = partial( lib_ra.find_valid_resource_agent_by_name, self.report_processor, self.runner, ) @patch_agent("reports.agent_name_guessed") @patch_agent("guess_exactly_one_resource_agent_full_name") def test_returns_guessed_agent(self, mock_guess, mock_report): #setup name = "Delay" guessed_name = "ocf:heartbeat:Delay" report = "AGENT_NAME_GUESSED" agent = mock.MagicMock(get_name=mock.Mock(return_value=guessed_name)) mock_guess.return_value = agent mock_report.return_value = report #test self.assertEqual(agent, self.run(name)) mock_guess.assert_called_once_with(self.runner, name) self.report_processor.process.assert_called_once_with(report) mock_report.assert_called_once_with(name, guessed_name) @patch_agent("ResourceAgent") def test_returns_real_agent_when_is_there(self, ResourceAgent): #setup name = "ocf:heartbeat:Delay" agent = mock.MagicMock() agent.validate_metadata = mock.Mock(return_value=agent) ResourceAgent.return_value = agent #test self.assertEqual(agent, self.run(name)) ResourceAgent.assert_called_once_with(self.runner, name) @patch_agent("resource_agent_error_to_report_item") @patch_agent("AbsentResourceAgent") @patch_agent("ResourceAgent") def test_returns_absent_agent_on_metadata_load_fail( self, ResourceAgent, AbsentResourceAgent, error_to_report_item ): #setup name = "ocf:heartbeat:Some" report = "UNABLE_TO_GET_AGENT_METADATA" e = lib_ra.UnableToGetAgentMetadata(name, "metadata missing") agent = 'absent agent' ResourceAgent.side_effect = e error_to_report_item.return_value = report AbsentResourceAgent.return_value = agent #test self.assertEqual(agent, self.run(name, allowed_absent=True)) ResourceAgent.assert_called_once_with(self.runner, name) AbsentResourceAgent.assert_called_once_with(self.runner, name) error_to_report_item.assert_called_once_with( e, severity=severity.WARNING, forceable=True ) self.report_processor.process.assert_called_once_with(report) @patch_agent("resource_agent_error_to_report_item") @patch_agent("ResourceAgent") def test_raises_on_metatdata_load_fail_disallowed_absent( self, ResourceAgent, error_to_report_item ): name = "ocf:heartbeat:Some" report = "UNABLE_TO_GET_AGENT_METADATA" e = lib_ra.UnableToGetAgentMetadata(name, "metadata missing") ResourceAgent.side_effect = e error_to_report_item.return_value = report with self.assertRaises(LibraryError) as context_manager: self.run(name) self.assertEqual(report, context_manager.exception.args[0]) ResourceAgent.assert_called_once_with(self.runner, name) error_to_report_item.assert_called_once_with(e) @patch_agent("resource_agent_error_to_report_item") @patch_agent("ResourceAgent") def test_raises_on_invalid_name(self, ResourceAgent, error_to_report_item): name = "ocf:heartbeat:Something:else" report = "INVALID_RESOURCE_AGENT_NAME" e = lib_ra.InvalidResourceAgentName(name, "invalid agent name") ResourceAgent.side_effect = e error_to_report_item.return_value = report with self.assertRaises(LibraryError) as context_manager: self.run(name) self.assertEqual(report, context_manager.exception.args[0]) ResourceAgent.assert_called_once_with(self.runner, name) error_to_report_item.assert_called_once_with(e) class AbsentResourceAgentTest(TestCase): @mock.patch.object(lib_ra.CrmAgent, "_load_metadata") def test_behaves_like_a_proper_agent(self, load_metadata): name = "ocf:heartbeat:Absent" runner = mock.MagicMock(spec_set=CommandRunner) load_metadata.return_value = "" agent = lib_ra.ResourceAgent(runner, name) absent = lib_ra.AbsentResourceAgent(runner, name) #metadata are valid absent.validate_metadata() self.assertTrue(absent.is_valid_metadata()) self.assertEqual(agent.get_name(), absent.get_name()) self.assertEqual( agent.get_description_info(), absent.get_description_info() ) self.assertEqual(agent.get_full_info(), absent.get_full_info()) self.assertEqual(agent.get_shortdesc(), absent.get_shortdesc()) self.assertEqual(agent.get_longdesc(), absent.get_longdesc()) self.assertEqual(agent.get_parameters(), absent.get_parameters()) self.assertEqual(agent.get_actions(), absent.get_actions()) self.assertEqual(([], []), absent.validate_parameters_values({ "whatever": "anything" })) pcs-0.9.155/pcs/lib/tools.py000066400000000000000000000024321301012375000155160ustar00rootroot00000000000000from __future__ import ( absolute_import, division, print_function, unicode_literals, ) def environment_file_to_dict(config): """ Parse systemd Environment file. This parser is simplified version of parser in systemd, because of their poor implementation. Returns configuration in dictionary in format: {