Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
SUSE:SLE-12-SP4:GA
mgr-push.19628
mgr-push-git-0.5286df2.obscpio
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File mgr-push-git-0.5286df2.obscpio of Package mgr-push.19628
07070100000000000041FD0000000000000000000000015FC8E0A600000000000000000000000000000000000000000000000900000000mgr-push07070100000001000081B40000000000000000000000015FC8E0A6000046AC000000000000000000000000000000000000001100000000mgr-push/COPYING 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. <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year> <name of author> This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 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. <signature of Ty Coon>, 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. 07070100000002000081B40000000000000000000000015FC8E0A600000026000000000000000000000000000000000000001200000000mgr-push/Makefileinclude ../../../rel-eng/Makefile.git 07070100000003000081B40000000000000000000000015FC8E0A600000344000000000000000000000000000000000000001900000000mgr-push/Makefile.pythonTHIS_MAKEFILE := $(realpath $(lastword $(MAKEFILE_LIST))) CURRENT_DIR := $(dir $(THIS_MAKEFILE)) include $(CURRENT_DIR)../../../rel-eng/Makefile.python # Docker tests variables DOCKER_CONTAINER_BASE = uyuni-master DOCKER_REGISTRY = registry.mgr.suse.de DOCKER_RUN_EXPORT = "PYTHONPATH=$PYTHONPATH" DOCKER_VOLUMES = -v "$(CURDIR)/../../../:/manager" __pylint :: $(call update_pip_env) pylint --rcfile=pylintrc $(shell find -name '*.py') > reports/pylint.log || true docker_pylint :: docker run --rm -e $(DOCKER_RUN_EXPORT) $(DOCKER_VOLUMES) $(DOCKER_REGISTRY)/$(DOCKER_CONTAINER_BASE)-pgsql /bin/sh -c "cd /manager/client/tools/mgr-push; make -f Makefile.python __pylint" docker_shell :: docker run -t -i --rm -e $(DOCKER_RUN_EXPORT) $(DOCKER_VOLUMES) $(DOCKER_REGISTRY)/$(DOCKER_CONTAINER_BASE)-pgsql /bin/bash 07070100000004000081B40000000000000000000000015FC8E0A600000508000000000000000000000000000000000000001A00000000mgr-push/Makefile.rhnpush# Makefile for the rhnpush module # INSTALL = install -D -p --verbose INSTALL_BIN = $(INSTALL) -m 755 INSTALL_DIR = $(INSTALL) -m 755 -d INSTALL_DATA = $(INSTALL) -m 644 SUBDIR = rhnpush FILES = rhnpush_main rhnpush_v2 uploadLib __init__ connection \ rpm2mpm utils rhnpush_cache \ rhnpush_config rhnpush_confmanager archive RHN_CONF_DIR = /etc/sysconfig/rhn RHNPUSHRC = rhnpushrc PYFILES := $(addsuffix .py, $(FILES)) OBJECTS := $(PYFILES) ROOT ?= /usr/share/rhn PYTHON_VERSION ?= 2 # check if we can build man pages DOCBOOK = $(wildcard /usr/bin/docbook2man) SGMLS = $(wildcard *.sgml) MANS = $(patsubst %.sgml,%.8,$(SGMLS)) BINDIR = /usr/bin MANDIR ?= /usr/man EXTRA_DIRS = $(MANDIR)/man8 $(BINDIR) $(RHN_CONF_DIR) install-conf : $(RHNPUSHRC) $(INSTALL_DATA) $(RHNPUSHRC) $(PREFIX)$(RHN_CONF_DIR)/$(RHNPUSHRC) %.inst: rhnpush.inst all : $(MANS) $(OBJECTS) install : all install-conf $(INSTALL_DIR) $(PREFIX)$(MANDIR)/man8 $(INSTALL_DATA) $(MANS) $(PREFIX)$(MANDIR)/man8 $(INSTALL_DIR) $(PREFIX)$(ROOT)/rhnpush $(INSTALL_DATA) $(PYFILES) $(PREFIX)$(ROOT)/rhnpush $(INSTALL_BIN) rhnpush $(PREFIX)$(BINDIR)/rhnpush-$(PYTHON_VERSION) @ln -sfv rhnpush $(PREFIX)$(BINDIR)/rpm2mpm %.8 : %.sgml /usr/bin/docbook2man $< 07070100000005000081B40000000000000000000000015FC8E0A600000265000000000000000000000000000000000000001500000000mgr-push/__init__.py# # Copyright (c) 2008--2015 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # 07070100000006000081B40000000000000000000000015FC8E0A6000033C4000000000000000000000000000000000000001400000000mgr-push/archive.py# # Copyright (c) 2008--2017 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # """Archive Parsing module""" import os import subprocess import shutil import tempfile import select import zipfile import tarfile import sys if not hasattr(zipfile, 'ZIP64_LIMIT'): sys.stderr.write("%s requires zipfile with ZIP64 support.\n" % sys.argv[0]) sys.exit(3) # exceptions ------------------------------------------------------------- class ArchiveException(Exception): pass class DecompressionError(ArchiveException): pass class UnknownArchiveError(ArchiveException): pass class InvalidArchiveError(ArchiveException): pass # base archive parsing class --------------------------------------------- class ArchiveParser(object): """Explode an zip or (compressed) tar archive and parse files and directories contained therein""" # constructor -------------------------------------------------------- def __init__(self, archive, tempdir="/tmp/"): """Initialize an archive parser""" assert os.path.exists(archive) self._archive = archive self._archive_dir = None # bug 164756: allow optional working directory self._parent_dir = tempdir # bug: 171086: support for older versions of tempfile (ie python 2.2) tempfile.tempdir = tempdir self._temp_dir = tempfile.mktemp() os.mkdir(self._temp_dir, int('0700', 8)) self._explode() # destructor --------------------------------------------------------- def __del__(self): """Cleanup temporary files and directories""" if hasattr(self, "_temp_dir") and os.path.isdir(self._temp_dir): shutil.rmtree(self._temp_dir, ignore_errors=True) # methods called by constructor -------------------------------------- def _get_archive_dir(self): """[internal] find the archive's top level directory name""" raise NotImplementedError("ArchiveParser: abstract base class method '_get_archive_dir'") def _explode_cmd(self): """[internal] find the appropriate command to open the archive""" raise NotImplementedError("ArchiveParser: abstract base class method '_explode_cmd'") def _explode(self): """[internal] Explode a archive for neutral parsing""" cmd = self._explode_cmd() assert self._archive is not None # assigned in _copy_archive assert self._archive_dir is not None # assigned in _explode_cmd if cmd: _my_popen(cmd) if os.path.isdir(self._archive_dir): return raise InvalidArchiveError("Archive did not expand to %s" % self._archive_dir) raise InvalidArchiveError("Could not find command to open archive: %s" % self._archive) # private helper methods --------------------------------------------- def _find(self, filename): """[internal] Returns the relative path to a file in the archive""" file_path = None contents = os.listdir(self._archive_dir) while contents: entry = contents.pop() path = os.path.join(self._archive_dir, entry) if os.path.isdir(path): p_contents = os.listdir(path) e_contents = [os.path.join(entry, e) for e in p_contents] # this really is something of a hack, the newest contents will # 'prepended' to the queue instead of 'appended' changing the # search into depth-first when I think breadth-first would be # the expected behavior # that's what we get for programming in python which doesn't # supply a nice way of adding real data-structure support # I already tried extending e_contents with contents and then # reassigning the contents reference to e_contents, but the # damn while loop still had a hold of the original reference contents.extend(e_contents) else: if entry.endswith(filename): file_path = entry break else: # if __degug__: sys.stderr.write("[_find] '%s' not found\n" % file) pass return file_path # public api --------------------------------------------------------- def list(self, prefix=""): """Return a tuple of directories and files in the archive at the given directory: prefix""" dirname = os.path.join(self._archive_dir, prefix) assert os.path.isdir(dirname) l = os.listdir(dirname) d = [] f = [] for i in l: if os.path.isdir(os.path.join(dirname, i)): d.append(i) else: f.append(i) return (d, f) def contains(self, filename): """Returns true iff the file is contained in the archive""" return self._find(filename) is not None def read(self, filename): """Returns the contents of the file, or None on error First occurence of that file in archive is returned """ f = self._find(filename) if f: return self.direct_read(f) return None def direct_read(self, filename): """ Returns the contens of the file, file is relative path in archive. Top most level (_get_archive_dir) is automaticaly added. """ # pylint: disable=W0703 f = os.path.join(os.path.abspath(self._archive_dir), filename) contents = None if os.path.isfile(f) and os.access(f, os.R_OK): try: fd = open(f) contents = fd.read() fd.close() except Exception: contents = None return contents def zip(self, prefix=""): """Create a zip archive of a (sub-)directory of the archive""" dirname = os.path.join(self._archive_dir, prefix) zip_dir = os.path.basename(dirname) parent_dir = os.path.dirname(dirname) cwd = os.getcwd() os.chdir(parent_dir) zip_file = os.path.join(self._parent_dir, "%s.zip" % zip_dir) fd = zipfile.ZipFile(zip_file, 'w', zipfile.ZIP_DEFLATED) for base, _dirs, files in os.walk(zip_dir): fd.write(base) for f in files: fd.write(os.path.join(base, f)) os.chdir(cwd) if os.path.isfile(zip_file): return zip_file return None def cpio(self, prefix): """Create a cpio archive of a (sub-)directory of the archive""" cpio_file = os.path.join(self._temp_dir, "%s.pkg" % prefix) cmd = "pkgtrans -s %s %s %s" % (self._archive_dir, cpio_file, prefix) _my_popen(cmd) if os.path.isfile(cpio_file): return cpio_file return None # parser for zip archives ------------------------------------------------ class ZipParser(ArchiveParser): def __init__(self, archive, tempdir="/tmp/"): self.zip_file = zipfile.ZipFile(archive, 'r') ArchiveParser.__init__(self, archive, tempdir) def _get_archive_dir(self): return self.zip_file.namelist()[0] def _explode(self): """Explode zip archive""" self._archive_dir = os.path.join(self._temp_dir, self._get_archive_dir()).rstrip('/') try: self.zip_file.extractall(self._temp_dir) except Exception: e = sys.exc_info()[1] raise InvalidArchiveError("Archive did not expand to %s: %s" % (self._archive_dir, str(e))) return def _explode_cmd(self): pass # parser for tar archives ------------------------------------------------ class TarParser(ArchiveParser): def __init__(self, archive, tempdir="/tmp/"): self.tar_file = tarfile.open(archive, 'r') ArchiveParser.__init__(self, archive, tempdir) def _get_archive_dir(self): return self.tar_file.getnames()[0] def _explode(self): """Explode tar archive""" self._archive_dir = os.path.join(self._temp_dir, self._get_archive_dir()) try: self.tar_file.extractall(path=self._temp_dir) except Exception: e = sys.exc_info()[1] raise InvalidArchiveError("Archive did not expand to %s: %s" % (self._archive_dir, str(e))) return def _explode_cmd(self): pass # parser for cpio archives ----------------------------------------------- class CpioParser(ArchiveParser): def _get_archive_dir(self): return os.path.basename(self._archive)[0:5] # arbitrary def _explode_cmd(self): """Return the appropriate command for exploding a cpio archive""" self._archive_dir = os.path.join(self._temp_dir, self._get_archive_dir()) if not _has_executable("pkgtrans"): raise ArchiveException("cannot open %s, 'pkgtrans' not found" % self._archive) return "cd %s; mkdir %s; pkgtrans %s %s all" % \ (self._temp_dir, self._archive_dir, self._archive, self._archive_dir) # internal helper methods ------------------------------------------------ def _has_executable(exc): """Return true if the executable is found in the $PATH""" # flag the error condition, this will evaluate to False if "PATH" not in os.environ: return None # this is posix specific dirs = os.environ["PATH"].split(':') for dirname in dirs: path = os.path.join(dirname, exc) if os.access(path, os.X_OK): return True return False def _my_popen(cmd): """Execute a command as a subprocess and return its exit status""" # pylint: disable=E1101 popen = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True, shell=True) popen.stdin.close() txt = "" while 1: rd, _wr, ex = select.select([popen.stdout, popen.stderr], [], [popen.stdout, popen.stderr], 5) if ex: txt += popen.stdout.read() txt += popen.stderr.read() break if rd: txt += rd[0].read() break status = popen.wait() if status != 0: raise Exception("%s exited with status %s and error\n%s" % (cmd, status, txt)) return # NOTE these next two functions rely on file magic to determine the compression # and archive types. some file magic information can be found here: # http://www.astro.keele.ac.uk/oldusers/rno/Computing/File_magic.html def _decompress(archive): """[internal] Decompress compressed archives and return the new archive name""" cmd = "" sfx_list = None # determine which type of compression we're dealing with, if any fd = open(archive, 'r') magic = fd.read(2) fd.close() if magic == "BZ": cmd = "bunzip2" sfx_list = (".bz2", ".bz") elif magic == "\x1F\x9D": cmd = "uncompress" sfx_list = (".Z",) elif magic == "\x1F\x8B": cmd = "gunzip" sfx_list = (".gz",) # decompress the archive if it is compressed if cmd: if not _has_executable(cmd): raise ArchiveException("Cannot decompress %s, '%s' not found" % (archive, cmd)) print("Decompressing archive") _my_popen("%s %s" % (cmd, archive)) # remove the now invalid suffix from the archive name for sfx in sfx_list: if archive[-len(sfx):] == sfx: archive = archive[:-len(sfx)] break return archive # archive parser factory ------------------------------------------------- def get_archive_parser(archive, tempdir="/tmp/"): """Factory function that returns an ArchiveParser object for the given archive""" # decompress the archive archive = _decompress(archive) parserClass = None fd = open(archive, 'r') magic = fd.read(4) if magic == "PK\x03\x04": parserClass = ZipParser fd.seek(0) magic = fd.read(20) if magic == "# PaCkAgE DaTaStReAm": parserClass = CpioParser fd.seek(257) magic = fd.read(5) if magic == "ustar": parserClass = TarParser # pre-posix tar doesn't have any standard file magic if archive.endswith(".tar"): parserClass = TarParser fd.close() if parserClass is None: raise UnknownArchiveError("Wasn't able to identify: '%s'" % archive) return parserClass(archive, tempdir) 07070100000007000081B40000000000000000000000015FC8E0A6000028FC000000000000000000000000000000000000001700000000mgr-push/connection.py# # Copyright (c) 2008--2017 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # import socket import base64 import sys # pylint: disable=F0401,E0611,W0632 from rhn import connections, rpclib from uyuni.common.usix import ListType, TupleType, IntType, raise_with_tb from uyuni.common.rhn_pkg import InvalidPackageError, package_from_filename from rhnpush.utils import tupleify_urlparse if sys.version_info[0] == 3: from urllib.parse import splitport from urllib.parse import urlparse else: from urlparse import urlparse from urllib import splitport # pylint: disable=C0412 # pylint: disable=W0622 class ConnectionError(Exception): pass # pylint: disable=R0902 class BaseConnection: def __init__(self, uri, proxy=None): self._scheme, (self._host, self._port), self._path = parse_url(uri)[:3] if proxy: arr = rpclib.get_proxy_info(proxy) self._proxy_host = arr[0] self._proxy_port = arr[1] self._proxy_username = arr[2] self._proxy_password = arr[3] else: self._proxy_host = None self._trusted_certs = None self._connection = None self._timeout = None def set_timeout(self, timeout): self._timeout = timeout def get_connection(self): if self._scheme not in ['http', 'https']: raise ValueError("Unsupported scheme", self._scheme) params = {} if self._timeout is not None: params['timeout'] = self._timeout if self._proxy_host: params.update({ 'host': self._host, 'port': self._port, 'proxy': "%s:%s" % (self._proxy_host, self._proxy_port), 'username': self._proxy_username, 'password': self._proxy_password, }) if self._scheme == 'http': return connections.HTTPProxyConnection(**params) params['trusted_certs'] = self._trusted_certs return connections.HTTPSProxyConnection(**params) else: if self._scheme == 'http': return connections.HTTPConnection(self._host, self._port, **params) params['trusted_certs'] = self._trusted_certs return connections.HTTPSConnection(self._host, self._port, **params) def connect(self): self._connection = self.get_connection() self._connection.connect() def putrequest(self, method, url=None, skip_host=0): if url is None: url = self._path return self._connection.putrequest(method, url=url, skip_host=skip_host) def __getattr__(self, name): return getattr(self._connection, name) class PackageUpload: header_prefix = "X-RHN-Upload" user_agent = "rhn-package-upload" def __init__(self, url, proxy=None): self.connection = BaseConnection(url, proxy) self.headers = {} self.package_name = None self.package_epoch = None self.package_version = None self.package_release = None self.package_arch = None self.checksum = None self.checksum_type = None self.nvra = None self._resp_headers = None self.packaging = None self._response = None def set_header(self, name, value): if name not in self.headers: vlist = self.headers[name] = [] else: vlist = self.headers[name] if not isinstance(vlist, (ListType, TupleType)): vlist = [vlist] vlist.append(value) def send_http_headers(self, method, content_length=None): try: self.connection.connect() except socket.error: e = sys.exc_info()[1] raise_with_tb(ConnectionError("Error connecting", str(e)), sys.exc_info()[2]) # Add content_length if 'Content-Length' not in self.headers and \ content_length is not None: self.set_header('Content-Length', content_length) self.connection.putrequest(method) # Additional headers for hname, hval in self.headers.items(): if not isinstance(hval, (ListType, TupleType)): hval = [hval] for v in hval: self.connection.putheader(str(hname), str(v)) self.connection.endheaders() def send_http_body(self, stream_body): if stream_body is None: return stream_body.seek(0, 0) buffer_size = 16384 while 1: buf = stream_body.read(buffer_size) if not buf: break try: self.connection.send(buf) except IOError: e = sys.exc_info()[1] raise_with_tb(ConnectionError("Error sending body", str(e)), sys.exc_info()[2]) def send_http(self, method, stream_body=None): if stream_body is None: content_length = 0 else: stream_body.seek(0, 2) content_length = stream_body.tell() self.send_http_headers(method, content_length=content_length) self.send_http_body(stream_body) self._response = self.connection.getresponse() self._resp_headers = self._response.msg return self._response def upload(self, filename, fileChecksumType, fileChecksum): """ Uploads a file. Returns (http_error_code, error_message) Sets: self.package_name self.package_epoch self.package_version self.package_release self.package_arch """ try: a_pkg = package_from_filename(filename) a_pkg.read_header() except InvalidPackageError: return -1, "Not an RPM: %s" % filename # Set some package data members self.package_name = a_pkg.header['name'] self.package_epoch = a_pkg.header['epoch'] self.package_version = a_pkg.header['version'] self.package_release = a_pkg.header['release'] if a_pkg.header.is_source: if 1051 in a_pkg.header.keys(): self.package_arch = 'nosrc' else: self.package_arch = 'src' else: self.package_arch = a_pkg.header['arch'] self.packaging = a_pkg.header.packaging nvra = [self.package_name, self.package_version, self.package_release, self.package_arch] if isinstance(nvra[3], IntType): # Old rpm format return -1, "Deprecated RPM format: %s" % filename self.nvra = nvra # use the precomputed passed checksum self.checksum_type = fileChecksumType self.checksum = fileChecksum # Set headers self.set_header("Content-Type", "application/x-rpm") self.set_header("User-Agent", self.user_agent) # Custom RHN headers prefix = self.header_prefix self.set_header("%s-%s" % (prefix, "Package-Name"), nvra[0]) self.set_header("%s-%s" % (prefix, "Package-Version"), nvra[1]) self.set_header("%s-%s" % (prefix, "Package-Release"), nvra[2]) self.set_header("%s-%s" % (prefix, "Package-Arch"), nvra[3]) self.set_header("%s-%s" % (prefix, "Packaging"), self.packaging) if self.checksum_type == 'md5': self.set_header("%s-%s" % (prefix, "File-MD5sum"), self.checksum) else: self.set_header("%s-%s" % (prefix, "File-Checksum-Type"), self.checksum_type) self.set_header("%s-%s" % (prefix, "File-Checksum"), self.checksum) a_pkg.input_stream.seek(0, 0) self._response = self.send_http('POST', stream_body=a_pkg.input_stream) a_pkg.input_stream.close() retval = self.process_response() self.connection.close() return retval def process_response(self): status = self._response.status reason = self._response.reason if status == 200: # OK return status, "OK" if status == 201: # Created return (status, "%s %s: %s-%s-%s.%s.rpm already uploaded" % ( self.checksum_type, self.checksum, self.nvra[0], self.nvra[1], self.nvra[2], self.nvra[3])) if status in (404, 409): # Conflict errstring = self.get_error_message(self._resp_headers) return status, errstring data = self._response.read() if status == 403: # In this case Authentication is no longer valid on server # client needs to re-authenticate itself. errstring = self.get_error_message(self._resp_headers) return status, errstring if status == 500: print("Internal server error", status, reason) errstring = self.get_error_message(self._resp_headers) return status, data + errstring return status, data def get_error_message(self, headers): prefix = self.header_prefix + '-Error' text = [x[1] for x in headers.getaddrlist(prefix + '-String')] # text is a list now, convert it to a string text = '\n'.join(text) # pylint: disable=W1505 text = base64.decodestring(text) return text def parse_url(url, scheme="http", path='/'): _scheme, netloc, _path, params, query, fragment = tupleify_urlparse( urlparse(url)) if not netloc: # No scheme - trying to patch it up ourselves? url = scheme + "://" + url _scheme, netloc, _path, params, query, fragment = tupleify_urlparse( urlparse(url)) if not netloc: # XXX raise Exception() (host, port) = splitport(netloc) if not _path: _path = path return (_scheme, (host, port), _path, params, query, fragment) 07070100000008000081B40000000000000000000000015FC8E0A60000003C000000000000000000000000000000000000001C00000000mgr-push/mgr-push-rpmlintrcaddFilter("suse-filelist-forbidden-sysconfig .*/sysconfig") 07070100000009000081B40000000000000000000000015FC8E0A60000233E000000000000000000000000000000000000001A00000000mgr-push/mgr-push.changes------------------------------------------------------------------- Thu Dec 03 13:38:22 CET 2020 - jgonzalez@suse.com - version 4.2.2-1 - defined __python for python2. - Excluded RHEL8 for Python 2 build. ------------------------------------------------------------------- Fri Sep 18 11:14:23 CEST 2020 - jgonzalez@suse.com - version 4.2.1-1 - Update package version to 4.2.0 ------------------------------------------------------------------- Wed Nov 27 16:42:09 CET 2019 - jgonzalez@suse.com - version 4.1.1-1 - replace spacewalk-usix and spacewalk-backend-libs with uyuni-common-libs - Bump version to 4.1.0 (bsc#1154940) ------------------------------------------------------------------- Wed May 15 20:08:24 CEST 2019 - jgonzalez@suse.com - version 4.0.6-1 - Obsolete newer versions of rhnpush ------------------------------------------------------------------- Wed May 15 15:00:24 CEST 2019 - jgonzalez@suse.com - version 4.0.5-1 - SPEC cleanup - Fix wrong bugzilla entry at changelog ------------------------------------------------------------------- Mon Apr 22 12:02:26 CEST 2019 - jgonzalez@suse.com - version 4.0.4-1 - add makefile and configuration for pylint ------------------------------------------------------------------- Wed Jan 16 12:16:04 CET 2019 - jgonzalez@suse.com - version 4.0.3-1 - Fix dependencies to spacewalk-backend-libs ------------------------------------------------------------------- Fri Oct 26 09:56:12 CEST 2018 - jgonzalez@suse.com - version 4.0.2-1 - Add Uyuni URL to package ------------------------------------------------------------------- Fri Aug 10 16:02:45 CEST 2018 - jgonzalez@suse.com - version 4.0.1-1 - Bump version to 4.0.0 (bsc#1104034) - Rename package to mgr-push to allow version 4.0.0 (bsc#1104034) - Fix copyright for the package specfile (bsc#1103696) ------------------------------------------------------------------- Mon Apr 23 08:53:06 CEST 2018 - jgonzalez@suse.com - version 5.5.113.2-1 - Sync with upstream (bsc#1083294) - rhnpush is needed on python2 due to spacewalk-proxy ------------------------------------------------------------------- Mon Mar 26 08:40:29 CEST 2018 - jgonzalez@suse.com - version 5.5.113.1-1 - Sync with upstream (bsc#1083294) - Build python2 on SUSE ------------------------------------------------------------------- Mon Mar 05 09:16:14 CET 2018 - jgonzalez@suse.com - version 5.5.111.2-1 - remove empty clean section from spec (bsc#1083294) ------------------------------------------------------------------- Fri Feb 23 10:48:18 CET 2018 - jgonzalez@suse.com - version 5.5.111.1-1 - Sync with upstream ------------------------------------------------------------------- Thu Oct 26 17:16:51 CEST 2017 - mc@suse.de - version 5.5.108.1-1 - move rhnpush files into proper python2/python3 subpackages ------------------------------------------------------------------- Wed Aug 09 12:11:07 CEST 2017 - fkobzik@suse.de - version 5.5.104.3-1 - disable pylint check during build also for RHEL7 ------------------------------------------------------------------- Mon May 29 15:40:35 CEST 2017 - mc@suse.de - version 5.5.104.2-1 - fixed pylint warnings disabled python3 pylint on Fedora 26+ for now - removed outdated solaris2mpm script ------------------------------------------------------------------- Fri Mar 31 09:59:14 CEST 2017 - mc@suse.de - version 5.5.104.1-1 - Pylint fixes in rhnpush ------------------------------------------------------------------- Tue Mar 07 16:00:37 CET 2017 - mc@suse.de - version 5.5.102.1-1 - Updated links to github in spec files - require spacewalk-usix indead of spacewalk-backend-usix ------------------------------------------------------------------- Wed Jan 11 15:34:37 CET 2017 - michele.bologna@suse.com - version 5.5.101.1-1 - Version 5.5.101-1 ------------------------------------------------------------------- Wed Apr 06 08:49:39 CEST 2016 - mc@suse.de - version 5.5.91.2-1 - don't count on having newest rhn-client-tools ------------------------------------------------------------------- Sat Jan 16 11:29:10 CET 2016 - mc@suse.de - version 5.5.91.1-1 - alow to use existing rpcServer when creating RhnServer ------------------------------------------------------------------- Mon Nov 30 10:59:38 CET 2015 - mc@suse.de - version 5.5.90.1-1 - rhn-satellite-activate: manual references removed ------------------------------------------------------------------- Wed Oct 07 15:56:48 CEST 2015 - mc@suse.de - version 5.5.89.1-1 - Wire in timeout for rhnpush ------------------------------------------------------------------- Mon Jun 22 15:30:09 CEST 2015 - jrenner@suse.de - version 5.5.71.8-1 - fix --ca-chain option for rhnpush (bsc#931503, bsc#895869) ------------------------------------------------------------------- Tue Feb 03 13:08:35 CET 2015 - mc@suse.de - version 5.5.71.7-1 - Getting rid of Tabs and trailing spaces ------------------------------------------------------------------- Thu Dec 18 13:33:42 CET 2014 - mc@suse.de - version 5.5.71.6-1 - rhnpush: fix pylint checks and code quality ------------------------------------------------------------------- Wed Sep 3 01:41:38 CEST 2014 - ro@suse.de - sanitize release line in specfile ------------------------------------------------------------------- Fri Jun 13 16:19:07 CEST 2014 - jrenner@suse.de - version 5.5.71.5-1 - Add default path structure to proxy lookaside that avoids collisions - Make rhnpush backwards-compatible with old spacewalk-proxy ------------------------------------------------------------------- Thu Apr 10 17:32:20 CEST 2014 - mc@suse.de - version 5.5.71.4-1 ------------------------------------------------------------------- Thu Apr 10 17:32:04 CEST 2014 - mc@suse.de - fix release in specfile for SLE12 (bnc#872970) ------------------------------------------------------------------- Thu Mar 27 10:07:33 CET 2014 - fcastelli@suse.com - version 5.5.71.3-1 - correcting exception type ------------------------------------------------------------------- Thu Feb 13 15:03:40 CET 2014 - mc@suse.de - version 5.5.71.2-1 - use SUSE package name in requires - pylint check only on SLE11 ------------------------------------------------------------------- Tue Dec 10 14:11:22 CET 2013 - mc@suse.de - version 5.5.71.1-1 - switch to 2.1 ------------------------------------------------------------------- Thu Aug 02 16:23:54 CEST 2012 - mc@suse.de - version 5.5.42.7-1 - code cleanup - fixed man page - removed dead --no-cache option - fixed --no-session-caching option ------------------------------------------------------------------- Mon Jul 16 15:17:44 CEST 2012 - ug@suse.de - version 5.5.42.6-1 - solaris2mpm on RHEL5 is not supported - solaris2mpm needs zipfile with ZIP64 extension - remove trailing '/' from from archive dir - reuse UploadError from uploadLib - simplified authentication code ------------------------------------------------------------------- Mon Jun 25 10:22:27 CEST 2012 - mc@suse.de - version 5.5.42.5-1 - removed commented out code and obsoleted comments ------------------------------------------------------------------- Thu Jun 21 10:52:17 CEST 2012 - jrenner@suse.de - version 5.5.42.4-1 - add COPYING file (bnc#764854) ------------------------------------------------------------------- Thu May 31 10:55:28 CEST 2012 - mc@suse.de - version 5.5.42.3-1 - Use the correct a_pkg variable. ------------------------------------------------------------------- Fri Apr 27 16:54:01 CEST 2012 - mc@suse.de - version 5.5.42.2-1 - removed unused get_header_struct_size() - removed unused function get_header_byte_range() ------------------------------------------------------------------- Wed Mar 21 17:35:17 CET 2012 - mc@suse.de - version 5.5.42.1-1 - Bumping package version ------------------------------------------------------------------- Tue Feb 22 16:23:06 CET 2011 - mantel@suse.de - add missing "import string" (bnc#672643) ------------------------------------------------------------------- Thu Feb 17 14:06:01 CET 2011 - mantel@suse.de - fix build: create symlink only after binary has been installed ------------------------------------------------------------------- Thu Feb 17 13:39:50 CET 2011 - mantel@suse.de - rename "Red Hat Network" to "SUSE Manager" for SUSE (bnc#672643) - add mgrpush symlink (bnc#672643) ------------------------------------------------------------------- Tue Feb 1 16:54:39 CET 2011 - mc@suse.de - fix build for RH4 ------------------------------------------------------------------- Tue Jan 11 16:39:04 CET 2011 - mc@suse.de - tag strings which needs changes - fix Requires line in spec ------------------------------------------------------------------- Wed Sep 15 12:16:32 CEST 2010 - mantel@suse.de - fix post-build-checks ------------------------------------------------------------------- Tue Sep 14 17:59:47 CEST 2010 - mantel@suse.de - Initial release of rhnpush ------------------------------------------------------------------- 0707010000000A000081B40000000000000000000000015FC8E0A600001596000000000000000000000000000000000000001700000000mgr-push/mgr-push.spec# # spec file for package mgr-push # # Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany. # Copyright (c) 2008-2018 Red Hat, Inc. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed # upon. The license for this file, and modifications and additions to the # file, is the same license as for the pristine package itself (unless the # license for the pristine package is not an Open Source License, in which # case the license is the MIT License). An "Open Source License" is a # license that conforms to the Open Source Definition (Version 1.9) # published by the Open Source Initiative. # Please submit bugfixes or comments via https://bugs.opensuse.org/ # # Old name and version+1 before renaming to mgr-push %define oldname rhnpush %define oldversion 5.5.114 %{!?pylint_check: %global pylint_check 0} %global __python /usr/bin/python2 %if 0%{?fedora} || 0%{?suse_version} > 1320 || 0%{?rhel} >= 8 %global build_py3 1 %global default_py3 1 %endif %if !( 0%{?rhel} >= 8 ) %global build_py2 1 %endif %define pythonX %{?default_py3: python3}%{!?default_py3: python2} Name: mgr-push Summary: Package uploader for the Spacewalk License: GPL-2.0-only Group: Applications/System Url: https://github.com/uyuni-project/uyuni Version: 4.2.2 Provides: %{oldname} = %{oldversion} Obsoletes: %{oldname} < %{oldversion} Release: 1%{?dist} Source0: https://github.com/spacewalkproject/spacewalk/archive/%{name}-%{version}.tar.gz Source1: %{name}-rpmlintrc BuildRoot: %{_tmppath}/%{name}-%{version}-build %if 0%{?fedora} || 0%{?rhel} || 0%{?suse_version} >= 1210 BuildArch: noarch %endif Requires: %{pythonX}-%{name} = %{version}-%{release} BuildRequires: docbook-utils BuildRequires: gettext %if 0%{?pylint_check} %if 0%{?build_py2} BuildRequires: spacewalk-python2-pylint %endif %if 0%{?build_py3} BuildRequires: spacewalk-python3-pylint %endif %endif %description rhnpush uploads package headers to the Spacewalk servers into specified channels and allows for several other channel management operations relevant to controlling what packages are available per channel. %if 0%{?build_py2} %package -n python2-%{name} Summary: Package uploader for the Spacewalk or Red Hat Satellite Server Group: Applications/System Provides: python2-%{oldname} = %{oldversion} Obsoletes: python2-%{oldname} < %{oldversion} Requires: %{name} = %{version}-%{release} %if 0%{?fedora} >= 28 Requires: python2-rpm BuildRequires: python2-devel %else Requires: rpm-python BuildRequires: python-devel %endif Requires: python2-rhn-client-tools Requires: rhnlib >= 2.8.3 Requires: python2-uyuni-common-libs BuildRequires: python2-rhn-client-tools BuildRequires: python2-uyuni-common-libs %description -n python2-%{name} Python 2 specific files for rhnpush. %endif %if 0%{?build_py3} %package -n python3-%{name} Summary: Package uploader for the Spacewalk or Red Hat Satellite Server Group: Applications/System Provides: python3-%{oldname} = %{oldversion} Obsoletes: python3-%{oldname} < %{oldversion} Requires: %{name} = %{version}-%{release} %if 0%{?suse_version} Requires: python3-rpm %else Requires: rpm-python3 %endif Requires: python3-rhn-client-tools Requires: python3-rhnlib >= 2.8.3 Requires: python3-uyuni-common-libs BuildRequires: python3-devel BuildRequires: python3-rhn-client-tools BuildRequires: python3-rpm-macros BuildRequires: python3-uyuni-common-libs %description -n python3-%{name} Python 3 specific files for rhnpush. %endif %prep %setup -q %build make -f Makefile.rhnpush all %install install -d $RPM_BUILD_ROOT/%{python_sitelib} %if 0%{?build_py2} make -f Makefile.rhnpush install PREFIX=$RPM_BUILD_ROOT ROOT=%{python_sitelib} \ MANDIR=%{_mandir} PYTHON_VERSION=%{python_version} %endif %if 0%{?build_py3} sed -i 's|#!/usr/bin/python|#!/usr/bin/python3|' rhnpush install -d $RPM_BUILD_ROOT/%{python3_sitelib} make -f Makefile.rhnpush install PREFIX=$RPM_BUILD_ROOT ROOT=%{python3_sitelib} \ MANDIR=%{_mandir} PYTHON_VERSION=%{python3_version} %endif %define default_suffix %{?default_py3:-%{python3_version}}%{!?default_py3:-%{python_version}} ln -s rhnpush%{default_suffix} $RPM_BUILD_ROOT%{_bindir}/rhnpush %if 0%{?suse_version} ln -s rhnpush $RPM_BUILD_ROOT/%{_bindir}/mgrpush %endif %check %if 0%{?pylint_check} # check coding style %if 0%{?build_py2} export PYTHONPATH=$RPM_BUILD_ROOT%{python_sitelib} spacewalk-python2-pylint $RPM_BUILD_ROOT%{_bindir} $RPM_BUILD_ROOT%{python_sitelib} %endif %if 0%{?build_py3} export PYTHONPATH=$RPM_BUILD_ROOT%{python3_sitelib} spacewalk-python3-pylint $RPM_BUILD_ROOT%{_bindir} $RPM_BUILD_ROOT%{python3_sitelib} %endif %endif %files %defattr(-,root,root) %{_bindir}/rhnpush %{_bindir}/rpm2mpm %dir %{_sysconfdir}/sysconfig/rhn %if 0%{?suse_version} %{_bindir}/mgrpush %endif %config(noreplace) %attr(644,root,root) %{_sysconfdir}/sysconfig/rhn/rhnpushrc %{_mandir}/man8/rhnpush.8* %doc COPYING %if 0%{?build_py2} %files -n python2-%{name} %defattr(-,root,root) %attr(755,root,root) %{_bindir}/rhnpush-%{python_version} %{python_sitelib}/rhnpush/ %endif %if 0%{?build_py3} %files -n python3-%{name} %defattr(-,root,root) %attr(755,root,root) %{_bindir}/rhnpush-%{python3_version} %{python3_sitelib}/rhnpush/ %endif %changelog 0707010000000B000041FD0000000000000000000000015FC8E0A600000000000000000000000000000000000000000000001100000000mgr-push/patches0707010000000C000081B40000000000000000000000015FC8E0A6000001FB000000000000000000000000000000000000002200000000mgr-push/patches/rhel4-static.dif--- solaris2mpm.py +++ solaris2mpm.py @@ -30,7 +30,6 @@ try: except ImportError: import md5 class hashlib: - @staticmethod def new(checksum): # Add sha1 if needed. if checksum == 'md5': @@ -39,6 +38,8 @@ except ImportError: if checksum not in ['md5', 'sha1']: raise ValueError, "Incompatible checksum type" + new = staticmethod(new) + from spacewalk.common import rhn_mpm from archive import get_archive_parser 0707010000000D000081B40000000000000000000000015FC8E0A600001396000000000000000000000000000000000000001200000000mgr-push/pylintrc# mgr-push package pylint configuration [MASTER] # Profiled execution. profile=no # Pickle collected data for later comparisons. persistent=no [MESSAGES CONTROL] # Disable the message(s) with the given id(s). disable=I0011, C0302, C0111, R0801, R0902, R0903, R0904, R0912, R0913, R0914, R0915, R0921, R0922, W0142, W0403, W0603, C1001, W0121, useless-else-on-loop, bad-whitespace, unpacking-non-sequence, superfluous-parens, cyclic-import, redefined-variable-type, no-else-return, # Uyuni disabled E0203, E0611, E1101, E1102 # list of disabled messages: #I0011: 62: Locally disabling R0201 #C0302: 1: Too many lines in module (2425) #C0111: 1: Missing docstring #R0902: 19:RequestedChannels: Too many instance attributes (9/7) #R0903: Too few public methods #R0904: 26:Transport: Too many public methods (22/20) #R0912:171:set_slots_from_cert: Too many branches (59/20) #R0913:101:GETServer.__init__: Too many arguments (11/10) #R0914:171:set_slots_from_cert: Too many local variables (38/20) #R0915:171:set_slots_from_cert: Too many statements (169/50) #W0142:228:MPM_Package.write: Used * or ** magic #W0403: 28: Relative import 'rhnLog', should be 'backend.common.rhnLog' #W0603: 72:initLOG: Using the global statement # for pylint-1.0 we also disable #C1001: 46, 0: Old-style class defined. (old-style-class) #W0121: 33,16: Use raise ErrorClass(args) instead of raise ErrorClass, args. (old-raise-syntax) #W:243, 8: Else clause on loop without a break statement (useless-else-on-loop) # pylint-1.1 checks #C:334, 0: No space allowed after bracket (bad-whitespace) #W:162, 8: Attempting to unpack a non-sequence defined at line 6 of (unpacking-non-sequence) #C: 37, 0: Unnecessary parens after 'not' keyword (superfluous-parens) #C:301, 0: Unnecessary parens after 'if' keyword (superfluous-parens) [REPORTS] # Set the output format. Available formats are text, parseable, colorized, msvs # (visual studio) and html output-format=parseable # Include message's id in output include-ids=yes # Tells whether to display a full report or only the messages reports=yes # Template used to display messages. This is a python new-style format string # used to format the message information. See doc for all details msg-template="{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}" [VARIABLES] # A regular expression matching names used for dummy variables (i.e. not used). dummy-variables-rgx=_|dummy [BASIC] # Regular expression which should only match correct module names #module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ module-rgx=([a-zA-Z_][a-zA-Z0-9_]+)$ # Regular expression which should only match correct module level names const-rgx=(([a-zA-Z_][a-zA-Z0-9_]*)|(__.*__))$ # Regular expression which should only match correct class names class-rgx=[a-zA-Z_][a-zA-Z0-9_]+$ # Regular expression which should only match correct function names function-rgx=[a-z_][a-zA-Z0-9_]{,42}$ # Regular expression which should only match correct method names method-rgx=[a-z_][a-zA-Z0-9_]{,42}$ # Regular expression which should only match correct instance attribute names attr-rgx=[a-z_][a-zA-Z0-9_]{,30}$ # Regular expression which should only match correct argument names argument-rgx=[a-z_][a-zA-Z0-9_]{,30}$ # Regular expression which should only match correct variable names variable-rgx=[a-z_][a-zA-Z0-9_]{,30}$ # Regular expression which should only match correct list comprehension / # generator expression variable names inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$ # Regular expression which should only match correct class sttribute names class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,42}|(__.*__))$ # Good variable names which should always be accepted, separated by a comma good-names=i,j,k,ex,Run,_ # Bad variable names which should always be refused, separated by a comma bad-names=foo,bar,baz,toto,tutu,tata # List of builtins function names that should not be used, separated by a comma bad-functions=apply,input [DESIGN] # Maximum number of arguments for function / method max-args=10 # Maximum number of locals for function / method body max-locals=20 # Maximum number of return / yield for function / method body max-returns=6 # Maximum number of branch for function / method body max-branchs=20 # Maximum number of statements in function / method body max-statements=50 # Maximum number of parents for a class (see R0901). max-parents=7 # Maximum number of attributes for a class (see R0902). max-attributes=7 # Minimum number of public methods for a class (see R0903). min-public-methods=1 # Maximum number of public methods for a class (see R0904). max-public-methods=20 [CLASSES] [FORMAT] # Maximum number of characters on a single line. max-line-length=120 # Maximum number of lines in a module max-module-lines=1000 # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 # tab). indent-string=' ' [MISCELLANEOUS] # List of note tags to take in consideration, separated by a comma. notes= 0707010000000E000081FD0000000000000000000000015FC8E0A6000002E6000000000000000000000000000000000000001100000000mgr-push/rhnpush#!/usr/bin/python # # Wrapper for rhnpush_main.py # import sys try: from rhnpush import rhnpush_main except ImportError: e = sys.exc_info()[1] sys.stderr.write("Unable to load module rhnpush_main\n") sys.stderr.write(str(e) + "\n") sys.exit(1) if __name__ == '__main__': try: sys.exit(rhnpush_main.main() or 0) except KeyboardInterrupt: e = sys.exc_info()[1] sys.stderr.write("\nUser interrupted process.\n") sys.exit(0) except SystemExit: e = sys.exc_info()[1] sys.exit(e.code) # pylint: disable=W0703 except Exception: e = sys.exc_info()[1] sys.stderr.write("\nERROR: unhandled exception occurred: (%s).\n" % e) sys.exit(-1) 0707010000000F000081B40000000000000000000000015FC8E0A60000329F000000000000000000000000000000000000001600000000mgr-push/rhnpush.sgml<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook V3.1//EN" [ <!ENTITY RHNSAT "Spacewalk Server" > <!ENTITY RHNPUSH "Spacewalk Package Pusher" > ]> <refentry> <RefMeta> <RefEntryTitle>rhnpush</RefEntryTitle><manvolnum>8</manvolnum> <RefMiscInfo>Version 2.0</RefMiscInfo> </RefMeta> <RefNameDiv> <RefName><command>rhnpush</command></RefName> <RefPurpose> Utility to push binary and source RPMs into an RHN channel. </RefPurpose> </RefNameDiv> <RefSynopsisDiv> <Synopsis> <cmdsynopsis> <command>rhnpush</command> <arg>options <replaceable>...</replaceable></arg> <arg>-v</arg> <arg>--verbose</arg> </cmdsynopsis> <cmdsynopsis> <arg>-d<replaceable>DIRECTORY</replaceable></arg> <arg>--dir=<replaceable>DIRECTORY</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>-c<replaceable>CHANNEL_LABEL</replaceable></arg> <arg>--channel=<replaceable>CHANNEL_LABEL</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>-n<replaceable>N_HEADERS_PER_CALL</replaceable></arg> <arg>--count=<replaceable>N_HEADERS_PER_CALL</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>-l</arg> <arg>--list</arg> </cmdsynopsis> <cmdsynopsis> <arg>-r<replaceable>RELATIVE_DIRECTORY</replaceable></arg> <arg>--reldir=<replaceable>RELATIVE_DIRECTORY</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>-o<replaceable>ORGANIZATION_ID</replaceable></arg> <arg>--orgid=<replaceable>ORGANIZATION_ID</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>-u<replaceable>USERNAME</replaceable></arg> <arg>--username=<replaceable>USERNAME</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>-p<replaceable>PASSWORD</replaceable></arg> <arg>--password=<replaceable>PASSWORD</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>-s</arg> <arg>--stdin</arg> </cmdsynopsis> <cmdsynopsis> <arg>-X<replaceable>glob</replaceable></arg> <arg>--exclude=<replaceable>GLOB</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>--force</arg> </cmdsynopsis> <cmdsynopsis> <arg>--nosig</arg> </cmdsynopsis> <cmdsynopsis> <arg>--newest</arg> </cmdsynopsis> <cmdsynopsis> <arg>--nullorg</arg> </cmdsynopsis> <cmdsynopsis> <arg>--header</arg> </cmdsynopsis> <cmdsynopsis> <arg>--source</arg> </cmdsynopsis> <cmdsynopsis> <arg>--server=<replaceable>SERVER</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>--proxy=<replaceable>PROXY:PORT</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>-N</arg> <arg>--new-cache</arg> </cmdsynopsis> <cmdsynopsis> <arg>--no-session-caching</arg> </cmdsynopsis> <cmdsynopsis> <arg>--extended-test</arg> </cmdsynopsis> <cmdsynopsis> <arg>--test</arg> </cmdsynopsis> <cmdsynopsis> <arg>--tolerant</arg> </cmdsynopsis> <cmdsynopsis> <arg>--timeout=<replaceable>SECONDS</replaceable></arg> </cmdsynopsis> <cmdsynopsis> <arg>-h</arg> <arg>--help</arg> </cmdsynopsis> <cmdsynopsis> <arg>-?</arg> <arg>--usage</arg> </cmdsynopsis> </Synopsis> </RefSynopsisDiv> <RefSect1><Title>Description</Title> <para> The &RHNPUSH; (<emphasis>rhnpush</emphasis>) pushes RPMs into locally managed channels on a &RHNSAT;. Refer to the Red Hat Satellite documentation for further reference. </para> </RefSect1> <RefSect1><Title>Options</Title> <variablelist> <varlistentry> <term>-v --verbose</term> <listitem> <para>Increase verbosity (can use multiple times).</para> </listitem> </varlistentry> <varlistentry> <term>-d<replaceable>DIRECTORY</replaceable> --dir=<replaceable>DIRECTORY</replaceable></term> <listitem> <para>process packages from this directory.</para> </listitem> </varlistentry> <varlistentry> <term>-c<replaceable>CHANNEL_LABEL</replaceable>, --channel=<replaceable>CHANNEL_LABEL</replaceable></term> <listitem> <para>process data for this specific channel (specified by label) only. NOTE: the channel's *label* is NOT the same as the channel's *name*.</para> </listitem> </varlistentry> <varlistentry> <term>-n<replaceable>N_HEADERS_PER_CALL</replaceable> --count=<replaceable>N_HEADERS_PER_CALL</replaceable></term> <listitem> <para>process this number of headers per call. Current default is 25. Must be an integer.</para> </listitem> </varlistentry> <varlistentry> <term>-l --list</term> <listitem> <para>only list the specified channels.</para> </listitem> </varlistentry> <varlistentry> <term>-r<replaceable>RELATIVE_DIRECTORY</replaceable> --reldir=<replaceable>RELATIVE_DIRECTORY</replaceable></term> <listitem> <para>relative directory to associate with each file.</para> </listitem> </varlistentry> <varlistentry> <term>-o<replaceable>ORGANIZATION_ID</replaceable> --orgid=<replaceable>ORGANIZATION_ID</replaceable></term> <listitem> <para>Your organization's ID number. Must be an integer.</para> </listitem> </varlistentry> <varlistentry> <term>-u<replaceable>USERNAME</replaceable> --username=<replaceable>USERNAME</replaceable></term> <listitem> <para>username of user that has administrative access to the specified channel.</para> </listitem> </varlistentry> <varlistentry> <term>-p<replaceable>PASSWORD</replaceable> --password=<replaceable>PASSWORD</replaceable></term> <listitem> <para>see --username.</para> </listitem> </varlistentry> <varlistentry> <term>-s --stdin</term> <listitem> <para>read the package names from standard-in (allows piping).</para> </listitem> </varlistentry> <varlistentry> <term>-X<replaceable>glob</replaceable> --exclude=<replaceable>GLOB</replaceable></term> <listitem> <para>exclude packages that matches this glob expression.</para> </listitem> </varlistentry> <varlistentry> <term>--force</term> <listitem> <para>force the package upload (overwrites if package is already uploaded).</para> </listitem> </varlistentry> <varlistentry> <term>--tolerant</term> <listitem> <para>If rhnpush errors while uploading a package, continue attempting to push the rest of the packages.</para> </listitem> </varlistentry> <varlistentry> <term>--nosig</term> <listitem> <para>don't fail if packages are unsigned.</para> </listitem> </varlistentry> <varlistentry> <term>--newest</term> <listitem> <para>push only the packages that are newer than those on the server.</para> <para>Please note that source RPMs are special in that their versions are never compared. Therefore, using this option with &RHNPUSH; will upload source RPMs for the specified channels only if they were not previously uploaded, and binaries built from them exist in those channels.</para> <para>In other words, you have to upload a binary rpm before being able to use <emphasis>--newest</emphasis> with its source rpm. </para> </listitem> </varlistentry> <varlistentry> <term>--timeout=<replaceable>SECONDS</replaceable></term> <listitem> <para>Change default connection timeout.</para> </listitem> </varlistentry> <varlistentry> <term>--nullorg</term> <listitem> <para>use the null org ID (most often the case).</para> </listitem> </varlistentry> <varlistentry> <term>--header</term> <listitem> <para>only upload the headers.</para> </listitem> </varlistentry> <varlistentry> <term>--source</term> <listitem> <para>the packages indicated are source packages (we treat them differently).</para> </listitem> </varlistentry> <varlistentry> <term>--server=<replaceable>SERVER</replaceable></term> <listitem> <para>push to this server. The format is http[s]://<hostname>/APP</para> </listitem> </varlistentry> <varlistentry> <term>--proxy=<replaceable>PROXY:PORT</replaceable></term> <listitem> <para>Use proxy server (<server>:<port>)</para> </listitem> </varlistentry> <varlistentry> <term>--test</term> <listitem> <para>only print the packages to be pushed, don't actually push them.</para> </listitem> </varlistentry> <varlistentry> <term>-N --new-cache</term> <listitem> <para>create a new username/password cache</para> </listitem> </varlistentry> <varlistentry> <term>--no-session-caching</term> <listitem> <para>This option disabled session token authentication. Useful if you want to push to two or more different servers.</para> </listitem> </varlistentry> <varlistentry> <term>--extended-test</term> <listitem> <para>perform a more verbose test.</para> </listitem> </varlistentry> <varlistentry> <term>-h --help</term> <listitem> <para>briefly describe the options.</para> </listitem> </varlistentry> <varlistentry> <term>-? --usage</term> <listitem> <para>usage summary.</para> </listitem> </varlistentry> </variablelist> </RefSect1> <RefSect1><Title>Notes on using rhnpush</Title> <simplelist> <member> Rhnpush has three configuration files called /etc/sysconfig/rhn/rhnpushrc, ~/.rhnpushrc, and ./.rhnpushrc. </member> <member> /etc/sysconfig/rhn/rhnpushrc is the system-wide default settings for rhnpush. </member> <member> ~/.rhnpushrc is the user-specific settings that override the system-wide settings. </member> <member> ./.rhnpushrc controls the directory specific settings that override the user-specific and system-specific settings. </member> <member> /etc/sysconfig/rhn/rhnpushrc must be present for rhnpush to function correctly. If it is missing, rhnpush will attempt to use a series of default settings stored internally as a replacement. ~/.rhnpushrc and ./.rhnpushrc are not required to be present, but will be used if they are present. They are not created automatically by rhnpush. </member> <member> Rhnpush uses a cache, stored at ~/.rhnpushcache, to temporarily hold the username and password for a user. </member> <member> If the cache is missing, it will be created by rhnpush. </member> <member> If the cache is present and not too old, the usename-password combo will be used as a convenience for the user. </member> <member> The amount of time a cache lasts is configurable in any of the three configuration files. </member> <member> If your username/password combination gets messed up you have two options. One, you can wait until the cache expires, which takes minutes by default. Two, you can use the --new_cache option to force rhnpush to let you reenter your username/password. </member> <member> Using the --stdin and --dir options at the same time works as follows: rhnpush will let you type in rpm names, each rpm name on a separate line. When you have finished entering in rpm names, hit Ctrl-D. Rhnpush will then grab the files from directory you specified with --dir, put them in a list with the rpms you listed through standard input, and send them to the channel that was listed on the command-line or in the configuration files. </member> </simplelist> </RefSect1> <RefSect1><Title>See Also</Title> <simplelist> <member>db-control(1) - embedded database environment only!</member> <member>rhn-charsets(8)</member> <member>rhn-schema-version(8)</member> <member>rhn-ssl-dbstore(8)</member> <member>satellite-debug(8)</member> <member>satellite-sync(8)</member> </simplelist> </RefSect1> <RefSect1><Title>Authors</Title> <simplelist> <member>Todd Warner <email>taw@redhat.com</email></member> <member>Mihai Ibanescu <email>misa@redhat.com</email></member> </simplelist> </RefSect1> </RefEntry> 07070100000010000081B40000000000000000000000015FC8E0A600000633000000000000000000000000000000000000001A00000000mgr-push/rhnpush_cache.py# # Copyright (c) 2008--2016 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # # rhnpush_cache.py # # Classes that control the caching of usernames and passwords, # along with the retrieval of the username and password. # # UserInfo - Instantiations of this class are pickled. # Cache won't be valid after a certain amount of time. # # CacheManager - Controls access to the cache. import os from rhnpush import utils # This is the class that contains the session. class RHNPushSession: def __init__(self): self.location = os.path.join(utils.get_home_dir(), ".rhnpushcache") self.session = None def setSessionString(self, session): self.session = session def getSessionString(self): return self.session def readSession(self): sessionfile = open(self.location, "r") self.session = sessionfile.read() sessionfile.close() def writeSession(self): sessionfile = open(self.location, "w") sessionfile.write(self.session) sessionfile.close() 07070100000011000081B40000000000000000000000015FC8E0A60000149C000000000000000000000000000000000000001B00000000mgr-push/rhnpush_config.py# # Copyright (c) 2008--2017 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # # # The configuration file parser for the rhnpush utility. # The majority of this code is taken from rhncfg/config_common/local_config.py # # 11/11/2004 John Wregglesworth # import sys # pylint: disable=F0401 if sys.version_info[0] == 3: import configparser as ConfigParser else: import ConfigParser # Class that contains the options read in from the config file. # Uses a ConfigParser to create a dictionary of the configuration options. # That dictionary is then used to add instance variables to the object dynamically. class rhnpushConfigParser: # pylint: disable=W0201 _instance = None def __init__(self, filename=None, ensure_consistency=False): # Defaults that are used if the ensure_consistency parameter of the constructor is true # and the config file that is being read is missing some values. self.options_defaults = { 'newest': '0', 'usage': '0', 'header': '0', 'test': '0', 'nullorg': '0', 'source': '0', 'stdin': '0', 'verbose': '0', 'force': '0', 'nosig': '0', 'list': '0', 'exclude': '', 'files': '', 'orgid': '', 'reldir': '', 'count': '', 'dir': '', 'server': 'http://rhn.redhat.com/APP', 'channel': '', 'cache_lifetime': '600', 'new_cache': '0', 'extended_test': '0', 'no_session_caching': '0', 'proxy': '', 'tolerant': '0', 'ca_chain': '/usr/share/rhn/RHN-ORG-TRUSTED-SSL-CERT', 'timeout': None } # Used to parse the config file. self.settings = ConfigParser.ConfigParser() # use options from the rhnpush section. self.section = "rhnpush" self.username = None self.password = None if filename: self.filename = filename self._read_config_files() # Take all of the options read from the configuration file and add them as attributes #(instance variables, member variables, whatever) of this object. self._add_config_as_attr(ensure_consistency=ensure_consistency) # Use the ConfigParser to read in the configuration file. def _read_config_files(self): try: self.settings.read([self.filename]) except IOError: e = sys.exc_info()[1] print(("Config File Error: line %s, file %s: %s" % (e.lineno, e.filename, e))) sys.exit(1) def write(self, fileobj): try: self.settings.write(fileobj) except IOError: e = sys.exc_info()[1] print(("Config File Error: line %s, file %s: %s" % (e.lineno, e.filename, e))) sys.exit(1) # Returns an option read in from the configuration files and specified by the string variable option. # This function can probably be safely removed, since all configuration options become attributes # of an instantiation of this class. def get_option(self, option): try: return self.settings.get(self.section, option) except (ConfigParser.NoOptionError, ConfigParser.NoSectionError): e = sys.exc_info()[1] print("Option/Section Error: line %s, file %s: %s" % (e.lineno, e.filename, e)) sys.exit(1) # Returns the keys of the attributes of the object. def keys(self): return list(self.__dict__.keys()) # Returns the keys of the options read in from the configuration files. def _keys(self): if self.settings.has_section(self.section): return self.settings.options(self.section) return () # Returns an option read in from the configuration files. def __getitem__(self, item): return self.get_option(item) def __delitem__(self, item): pass def __len__(self): pass def __setitem__(self, key, value): pass # Takes all of the configuration options read in by the ConfigParser and makes them attributes of the object. def _add_config_as_attr(self, ensure_consistency=False): for k in self._keys(): self.__dict__[k] = self.settings.get(self.section, k) # ensuring consistency only checks for missing configuration option. if ensure_consistency: for thiskey in self.options_defaults: if thiskey not in self.__dict__: self.__dict__[thiskey] = self.options_defaults[thiskey] 07070100000012000081B40000000000000000000000015FC8E0A600001367000000000000000000000000000000000000002000000000mgr-push/rhnpush_confmanager.py# # Copyright (c) 2008--2016 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # import sys import os from rhnpush import rhnpush_config from rhnpush import utils class ConfManager: def __init__(self, optionparser, store_true_list): sysdir = '/etc/sysconfig/rhn' homedir = utils.get_home_dir() default = 'rhnpushrc' regular = '.rhnpushrc' deffile = os.path.join(sysdir, default) regfile = os.path.join(homedir, regular) cwdfile = os.path.join(os.getcwd(), regular) self.cfgFileList = [deffile, regfile, cwdfile] self.defaultconfig = rhnpush_config.rhnpushConfigParser(ensure_consistency=True) # Get a reference to the object containing command-line options self.cmdconfig = optionparser self.store_true_list = store_true_list # Change the files options of the self.userconfig # Change the exclude options of the self.userconfig def _files_to_list(self): # Change the files options to lists. if ('files' in self.defaultconfig.__dict__ and not isinstance(self.defaultconfig.files, type([]))): self.defaultconfig.files = [x.strip() for x in self.defaultconfig.files.split(',')] # Change the exclude options to list. if ('exclude' in self.defaultconfig.__dict__ and not isinstance(self.defaultconfig.__dict__['exclude'], type([]))): self.defaultconfig.exclude = [x.strip() for x in self.defaultconfig.exclude.split(',')] def get_config(self): for f in self.cfgFileList: if os.access(f, os.F_OK): if not os.access(f, os.R_OK): print(("rhnpush does not have read permission on %s" % f)) sys.exit(1) config2 = rhnpush_config.rhnpushConfigParser(f) self.defaultconfig, config2 = utils.make_common_attr_equal(self.defaultconfig, config2) self._files_to_list() # Change the channel string into a list of strings. # pylint: disable=E1103 if not self.defaultconfig.channel: # if no channel then make it null array instead of # an empty string array from of size 1 [''] . self.defaultconfig.channel = [] else: self.defaultconfig.channel = [x.strip() for x in self.defaultconfig.channel.split(',')] # Get the command line arguments. These take precedence over the other settings argoptions, files = self.cmdconfig.parse_args() # Makes self.defaultconfig compatible with argoptions by changing all '0' value attributes to None. _zero_to_none(self.defaultconfig, self.store_true_list) # If verbose isn't set at the command-line, it automatically gets set to zero. If it's at zero, change it to # None so the settings in the config files take precedence. if argoptions.verbose == 0: argoptions.verbose = None # Orgid, count, cache_lifetime, and verbose all need to be integers, just like in argoptions. if self.defaultconfig.orgid: self.defaultconfig.orgid = int(self.defaultconfig.orgid) if self.defaultconfig.count: self.defaultconfig.count = int(self.defaultconfig.count) if self.defaultconfig.cache_lifetime: self.defaultconfig.cache_lifetime = int(self.defaultconfig.cache_lifetime) if self.defaultconfig.verbose: self.defaultconfig.verbose = int(self.defaultconfig.verbose) if self.defaultconfig.timeout: self.defaultconfig.timeout = int(self.defaultconfig.timeout) # Copy the settings in argoptions into self.defaultconfig. self.defaultconfig, argoptions = utils.make_common_attr_equal(self.defaultconfig, argoptions) # Make sure files is in the correct format. if self.defaultconfig.files != files: self.defaultconfig.files = files return self.defaultconfig # Changes every option in config that is also in store_true_list that is set to '0' to None def _zero_to_none(config, store_true_list): for opt in config.keys(): for cmd in store_true_list: if str(opt) == cmd and config.__dict__[opt] == '0': config.__dict__[opt] = None 07070100000013000081FD0000000000000000000000015FC8E0A60000689D000000000000000000000000000000000000001900000000mgr-push/rhnpush_main.py# # Copyright (c) 2008--2017 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # # """ Management tool for the Spacewalk Proxy. This script performs various management operations on the Spacewalk Proxy: - Creates the local directory structure needed to store local packages - Uploads packages from a given directory to the RHN servers - Optionally, once the packages are uploaded, they can be linked to (one or more) channels, and copied in the local directories for these channels. - Lists the RHN server's vision on a certain channel - Checks if the local image of the channel (the local directory) is in sync with the server's image, and prints the missing packages (or the extra ones) """ import os import random import sys import time # pylint: disable=W0402 from optparse import Option, OptionParser # pylint: disable=F0401,E0611 from rhn.connections import idn_ascii_to_puny from rhn import rpclib from rhn.i18n import sstr from uyuni.common.rhn_pkg import InvalidPackageError, package_from_filename from uyuni.common.usix import raise_with_tb from rhnpush.utils import tupleify_urlparse from rhnpush import rhnpush_confmanager, uploadLib, rhnpush_v2 if sys.version_info[0] == 3: import urllib.parse as urlparse else: import urlparse # Global settings BUFFER_SIZE = 65536 HEADERS_PER_CALL = 10 DEBUG = 0 RPMTAG_NOSOURCE = 1051 def main(): # Initialize a command-line processing object with a table of options optionsTable = [ Option('-v', '--verbose', action='count', help='Increase verbosity', default=0), Option('-d', '--dir', action='store', help='Process packages from this directory'), Option('-c', '--channel', action='append', help='Manage this channel (specified by label)'), Option('-n', '--count', action='store', help='Process this number of headers per call', type='int'), Option('-l', '--list', action='store_true', help='Only list the specified channels'), Option('-r', '--reldir', action='store', help='Relative dir to associate with the file'), Option('-o', '--orgid', action='store', help='Org ID', type='int'), Option('-u', '--username', action='store', help='Use this username to connect to RHN/Satellite'), Option('-p', '--password', action='store', help='Use this password to connect to RHN/Satellite'), Option('-s', '--stdin', action='store_true', help='Read the package names from stdin'), Option('-X', '--exclude', action='append', help='Exclude packages that match this glob expression'), Option('--force', action='store_true', help='Force the package upload (overwrites if already uploaded)'), Option('--nosig', action='store_true', help='Push unsigned packages'), Option('--newest', action='store_true', help='Only push the packages that are newer than the server ones'), Option('--nullorg', action='store_true', help='Use the null org id'), Option('--header', action='store_true', help='Upload only the header(s)'), Option('--source', action='store_true', help='Upload source package information'), Option('--server', action='store', help='Push to this server (http[s]://<hostname>/APP)'), Option('--proxy', action='store', help='Use proxy server (<server>:<port>)'), Option('--test', action='store_true', help='Only print the packages to be pushed'), Option('-?', '--usage', action='store_true', help='Briefly describe the options'), Option('-N', '--new-cache', action='store_true', help='Create a new username/password cache'), Option('--extended-test', action='store_true', help='Perform a more verbose test'), Option('--no-session-caching', action='store_true', help='Disables session-token authentication.'), Option('--tolerant', action='store_true', help='If rhnpush errors while uploading a package, continue uploading the rest of the packages.'), Option('--ca-chain', action='store', help='alternative SSL CA Cert'), Option('--timeout', action='store', type='int', metavar='SECONDS', help='Change default connection timeout.') ] # Having to maintain a store_true list is ugly. I'm trying to get rid of this. true_list = ['usage', 'test', 'source', 'header', 'nullorg', 'newest', 'nosig', 'force', 'list', 'stdin', 'new_cache', 'extended_test', 'no_session_caching', 'tolerant'] # pylint: disable=E1101,E1103 optionParser = OptionParser(option_list=optionsTable, usage="%prog [OPTION] [<package>]") manager = rhnpush_confmanager.ConfManager(optionParser, true_list) options = manager.get_config() upload = UploadClass(options, files=options.files) if options.usage: optionParser.print_usage() sys.exit(0) if options.proxy: options.proxy = idn_ascii_to_puny(options.proxy) if options.list: if not options.channel: upload.die(1, "Must specify a channel for --list to work") upload.list() return if options.dir and not options.stdin: upload.directory() elif options.stdin and not options.dir: upload.readStdin() elif options.dir and options.stdin: upload.readStdin() upload.directory() if options.exclude: upload.filter_excludes() if options.newest: if not options.channel: upload.die(1, "Must specify a channel for --newest to work") upload.newest() if not upload.files: if upload.newest: print("No new files to upload; exiting") else: print("Nothing to do (try --help for more options)") sys.exit(0) if options.test: upload.test() return if options.extended_test: upload.extended_test() return if options.header: upload.uploadHeaders() return ret = upload.packages() if ret != 0: return 1 class UploadClass(uploadLib.UploadClass): # pylint: disable=E1101,W0201,W0632 def __init__(self, options, files=None): uploadLib.UploadClass.__init__(self, options, files) self.url_v2 = None def setURL(self): server = sstr(idn_ascii_to_puny(self.options.server)) if server is None: self.die(1, "Required parameter --server not supplied") scheme, netloc, path, params, query, fragment = tupleify_urlparse( urlparse.urlparse(server)) if not netloc: # No schema - trying to patch it up ourselves? server = "http://%s" % server scheme, netloc, path, params, query, fragment = tupleify_urlparse( urlparse.urlparse(server)) if not netloc: self.die(2, "Invalid URL %s" % server) if path == '': path = '/APP' if scheme.lower() not in ('http', 'https'): self.die(3, "Unknown URL scheme %s" % scheme) self.url = urlparse.urlunparse((scheme, netloc, path, params, query, fragment)) self.url_v2 = urlparse.urlunparse((scheme, netloc, "/PACKAGE-PUSH", params, query, fragment)) def setOrg(self): if self.options.nullorg: if self.options.force: self.die(1, "ERROR: You cannot force a package to a nullorg channel.") else: # They push things to the None org id self.orgId = '' else: self.orgId = self.options.orgid or -1 def setForce(self): if self.options.force: self.force = 4 else: self.force = None def setRelativeDir(self): self.relativeDir = self.options.reldir def setChannels(self): self.channels = self.options.channel or [] # pylint: disable=W0702 def _test_force(self): test_force_str = "Setting force flag: %s" test_force = "Passed" try: self.setForce() except: test_force = "Failed" print(test_force_str % test_force) def _test_set_org(self): test_set_org_str = "Setting the org: %s" test_set_org = "Passed" try: self.setOrg() except: test_set_org = "Failed" print(test_set_org_str % test_set_org) def _test_set_url(self): test_set_url_str = "Setting the URL: %s" test_set_url = "Passed" try: self.setURL() except: test_set_url = "Failed" print(test_set_url_str % test_set_url) def _test_set_channels(self): test_set_channels_str = "Setting the channels: %s" test_set_channels = "Passed" try: self.setChannels() except: test_set_channels = "Failed" print(test_set_channels_str % test_set_channels) def _test_username_password(self): test_user_pass_str = "Setting the username and password: %s" test_user_pass = "Passed" try: self.setUsernamePassword() except: test_user_pass = "Failed" print(test_user_pass_str % test_user_pass) def _test_set_server(self): test_set_server_str = "Setting the server: %s" test_set_server = "Passed" try: self.setServer() except: test_set_server = "Failed" print(test_set_server_str % test_set_server) def _test_connect(self): auth_ret = uploadLib.call(self.server.packages.test_login, self.username, self.password) if auth_ret == 1: test_auth = "Passed" else: test_auth = "Failed" print("Testing connection and authentication: %s" % test_auth) def _test_access(self): access_ret = callable(self.server.packages.channelPackageSubscriptionBySession) if access_ret == 1: test_access = "Passed" else: test_access = "Failed" print("Testing access to upload functionality on server: %s" % test_access) # 12/22/05 wregglej 173287 Added a this funtion to test the new session authentication stuff. # It still needs work. def _test_authenticate(self): self.authenticate() def extended_test(self): self._test_force() self._test_set_org() self._test_set_url() self._test_set_channels() self._test_username_password() self._test_set_server() self._test_connect() self._test_access() print("The files that would have been pushed:") self.test() def packages(self): self.setForce() # set the org self.setOrg() # set the URL self.setURL() # set the channels self.setChannels() # set the server self.setServer() # 12/22/05 wregglej 173287 authenticate the session. self.authenticate() # Do we have the new-style handler available? # ping the server for status self.warn(2, "url is", self.url_v2) ping = rhnpush_v2.PingPackageUpload(self.url_v2, self.options.proxy) ping_status, errmsg, headerinfo = ping.ping() self.warn(2, "Result codes:", ping_status, errmsg) # move patch clusters to the end because all the patches in the cluster # have to be pushed before the cluster itself files1 = [] files2 = [] for filename in self.files: if filename.startswith('patch-cluster-'): files2.append(filename) else: files1.append(filename) self.files = files1 + files2 channel_packages = [] # a little fault tolarence is in order random.seed() tries = 3 # satellites < 4.1.0 are no more supported if sys.version_info[0] == 3: pack_exist_check = headerinfo.get('X-RHN-Check-Package-Exists') else: pack_exist_check = headerinfo.getheader('X-RHN-Check-Package-Exists') if not pack_exist_check: self.die(-1, "Pushing to Satellite < 4.1.0 is not supported.") (server_digest_hash, pkgs_info, digest_hash) = self.check_package_exists() for pkg in self.files: ret = None # pkilambi:errors off as not initialized.this fixes it. # temporary fix for picking pkgs instead of full paths pkg_key = (pkg.strip()).split('/')[-1] if pkg_key not in server_digest_hash: continue checksum_type, checksum = digest = digest_hash[pkg_key] server_digest = tuple(server_digest_hash[pkg_key]) # compare checksums for existance check if server_digest == digest and not self.options.force: channel_packages.append(pkgs_info[pkg_key]) self.warn(1, "Package %s already exists on the SUSE Manager Server-- Skipping Upload...." % pkg) continue elif server_digest == (): self.warn(1,"Package %s Not Found on SUSE Manager Server -- Uploading" % pkg) elif server_digest == "on-disk" and not self.options.force: channel_packages.append(pkgs_info[pkg_key]) self.warn(0, "Package on disk but not on db -- Skipping Upload " % pkg) continue elif server_digest != digest: if self.options.force: self.warn(1, "Package checksum %s mismatch -- Forcing Upload" % pkg) else: msg = "Error: Package %s already exists on the server with" \ " a different checksum. Skipping upload to prevent" \ " overwriting existing package. (You may use rhnpush with" \ " the --force option to force this upload if the" \ " force_upload option is enabled on your server.)\n" % pkg if not self.options.tolerant: self.die(-1, msg) self.warn(0, msg) continue for _t in range(0, tries): try: ret = self.package(pkg, checksum_type, checksum) if ret is None: raise uploadLib.UploadError() # TODO: Revisit this. We throw this error all over the place, # but doing so will cause us to skip the --tolerant logic # below. I don't think we really want this behavior. # There are some cases where we don't want to retry 3 # times, but not at the expense of disabling the tolerant # flag, IMHO. This loop needs some lovin'. -- pav # FIX: it checks for tolerant flag and aborts only if the flag is #not specified except uploadLib.UploadError: ue = sys.exc_info()[1] if not self.options.tolerant: self.die(1, ue) self.warn(2, ue) except AuthenticationRequired: # session expired so we re-authenticate for the process to complete # this uses the username and password from memory if available # else it prompts for one. self.authenticate() except: self.warn(2, sys.exc_info()[1]) wait = random.randint(1, 5) self.warn(0, "Waiting %d seconds and trying again..." % wait) time.sleep(wait) # The else clause gets executed in the stuff in the try-except block *succeeds*. else: break # if the preceeding for-loop exits without a call to break, then this else clause gets called. # What's kind of weird is that if the preceeding for-loop doesn't call break then an error occurred # and all of retry attempts failed. If the for-loop *does* call break then everything is hunky-dory. # In short, this else clause only get's called if something is F.U.B.A.R and the retry attempts don't # fix anything. else: if not self.options.tolerant: # pkilambi:bug#176358:this exits with a error code of 1 self.die(1, "Giving up after %d attempts" % tries) else: print("Giving up after %d attempts and continuing on..." % (tries,)) # 5/13/05 wregglej - 154248 ?? we still want to add the packages if they're source. if ret and self.channels: # and ret['arch'] != 'src': # Don't bother to add the package if # no channel was specified or a source rpm was passed channel_packages.append(ret) # self.channels is never None, it always has at least one entry with an empty string. if len(self.channels) == 1 and self.channels[0] == '': return info = { 'packages': channel_packages, 'channels': self.channels } if self.orgId == '' or self.orgId > 0: info['orgId'] = self.orgId # 2/3/06 wregglej 173287 Added check to see if we can use session tokens. if channel_packages: self.authenticate() uploadLib.call(self.server.packages.channelPackageSubscriptionBySession, self.session.getSessionString(), info) return 0 # does an existance check of the packages to be uploaded and returns their checksum and other info def check_package_exists(self): self.warn(2, "Computing checksum and package info. This may take some time ...") pkg_hash = {} digest_hash = {} for pkg in self.files: pkg_info = {} pkg_key = (pkg.strip()).split('/')[-1] if not os.access(pkg, os.R_OK): if not self.options.tolerant: self.die(-1, "Could not read file %s" % pkg) self.warn(-1, "Could not read file %s" % pkg) continue try: a_pkg = package_from_filename(pkg) a_pkg.read_header() a_pkg.payload_checksum() except InvalidPackageError: if not self.options.tolerant: self.die(-1, "ERROR: %s: This file doesn't appear to be a package" % pkg) self.warn(2, "ERROR: %s: This file doesn't appear to be a package" % pkg) continue except IOError: if not self.options.tolerant: self.die(-1, "ERROR: %s: No such file or directory available" % pkg) self.warn(2, "ERROR: %s: No such file or directory available" % pkg) continue digest_hash[pkg_key] = (a_pkg.checksum_type, a_pkg.checksum) a_pkg.input_stream.close() for tag in ('name', 'version', 'release', 'epoch', 'arch'): val = a_pkg.header[tag] if val is None: val = '' pkg_info[tag] = val # b195903:the arch for srpms should be obtained by is_source check # instead of checking arch in header if a_pkg.header.is_source: if not self.options.source: self.die(-1, "ERROR: Trying to Push src rpm, Please re-try with --source.") if RPMTAG_NOSOURCE in a_pkg.header.keys(): pkg_info['arch'] = 'nosrc' else: pkg_info['arch'] = 'src' pkg_info['checksum_type'] = a_pkg.checksum_type pkg_info['checksum'] = a_pkg.checksum pkg_hash[pkg_key] = pkg_info if self.options.nullorg: # to satisfy xmlrpc from None values. orgid = 'null' else: orgid = '' info = { 'packages': pkg_hash, 'channels': self.channels, 'org_id': orgid, 'force': self.options.force or 0 } # rpc call to get checksum info for all the packages to be uploaded if not self.options.source: # computing checksum and other info is expensive process and session # could have expired.Make sure its re-authenticated. self.authenticate() if uploadLib.exists_getPackageChecksumBySession(self.server): checksum_data = uploadLib.getPackageChecksumBySession(self.server, self.session.getSessionString(), info) else: # old server only md5 capable checksum_data = uploadLib.getPackageMD5sumBySession(self.server, self.session.getSessionString(), info) else: # computing checksum and other info is expensive process and session # could have expired.Make sure its re-authenticated. self.authenticate() if uploadLib.exists_getPackageChecksumBySession(self.server): checksum_data = uploadLib.getSourcePackageChecksumBySession(self.server, self.session.getSessionString(), info) else: # old server only md5 capable checksum_data = uploadLib.getSourcePackageMD5sumBySession(self.server, self.session.getSessionString(), info) return (checksum_data, pkg_hash, digest_hash) def package(self, package, fileChecksumType, fileChecksum): self.warn(1, "Uploading package %s" % package) if not os.access(package, os.R_OK): self.die(-1, "Could not read file %s" % package) try: h = uploadLib.get_header(package, source=self.options.source) except uploadLib.UploadError: e = sys.exc_info()[1] # GS: MALFORMED PACKAGE print("Unable to load package", package, ":", e) return None if hasattr(h, 'packaging'): packaging = h.packaging else: packaging = 'rpm' if packaging == 'rpm' and self.options.nosig is None and not h.is_signed(): # pkilambi:bug#173886:force exit to check for sig if --nosig raise uploadLib.UploadError("ERROR: %s: unsigned rpm (use --nosig to force)" % package) try: ret = self._push_package_v2(package, fileChecksumType, fileChecksum) except uploadLib.UploadError: e = sys.exc_info()[1] ret, diff_level, pdict = e.args[:3] severities = { 1: 'path changed', 2: 'package resigned', 3: 'differing build times or hosts', 4: 'package recompiled', } if diff_level in severities: strmsg = \ "Error: Package with same name already exists on " + \ "server but contents differ (" + \ severities[diff_level] + \ "). Use --force or remove old package before " + \ "uploading the newer version." else: strmsg = "Error: severity %s" % diff_level self.warn(-1, "Uploading failed for %s\n%s\n\tDiff: %s" % (package, strmsg, pdict['diff']['diff'])) if diff_level != 1: # This will prevent us from annoyingly retrying when there is # no reason to. raise uploadLib.UploadError() return ret return ret def _push_package_v2(self, package, fileChecksumType, fileChecksum): self.warn(1, "Using POST request") pu = rhnpush_v2.PackageUpload(self.url_v2, self.options.proxy) pu.set_session(self.session.getSessionString()) pu.set_force(self.options.force) pu.set_null_org(self.options.nullorg) pu.set_timeout(self.options.timeout) status, msgstr = pu.upload(package, fileChecksumType, fileChecksum) ret = {} for tag in ('name', 'version', 'release', 'epoch', 'arch'): val = getattr(pu, "package_%s" % tag) if val is None: val = '' ret[tag] = val ret['checksum_type'] = fileChecksumType ret['checksum'] = fileChecksum if status == 400: # Bad request - something bad happened try: data = rpclib.xmlrpclib.loads(msgstr) except: # Raise the exception instead of silently dying raise_with_tb(uploadLib.UploadError("Error pushing %s: %s (%s)" % (package, msgstr, status)), sys.exc_info()[2]) (diff_dict, ), methodname = data del methodname diff_level = diff_dict['level'] pdict = diff_dict['diff'] raise uploadLib.UploadError(ret, diff_level, pdict) if status == 403: # auth expired raise an exception to grab one raise AuthenticationRequired() if status != 200: self.die(1, "Error pushing %s: %s (%s)" % (package, msgstr, status)) return ret class AuthenticationRequired(Exception): pass if __name__ == '__main__': # test code sys.exit(main() or 0) 07070100000014000081B40000000000000000000000015FC8E0A600000912000000000000000000000000000000000000001700000000mgr-push/rhnpush_v2.py# # Copyright (c) 2008--2016 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # # # Package uploading tool # import base64 from rhnpush import connection class PackageUpload(connection.PackageUpload): user_agent = "rhnpush" def set_auth(self, username, password): auth_vals = self.encode_values([username, password]) self.headers["%s-%s" % (self.header_prefix, "Auth")] = auth_vals def set_session(self, session_string): self.headers["%s-%s" % (self.header_prefix, "Auth-Session")] = session_string def set_force(self, force): if force: force = 1 else: force = 0 self.headers["%s-%s" % (self.header_prefix, "Force")] = str(force) def set_null_org(self, null_org): if null_org: self.headers["%s-%s" % (self.header_prefix, "Null-Org")] = "1" def set_timeout(self, timeout): self.connection.set_timeout(timeout) # Encodes an array of variables into Base64 (column-separated) @staticmethod def encode_values(arr): val = ':'.join([x.strip() for x in map(base64.encodestring, arr)]) # Get rid of the newlines val = val.replace('\n', '') # And split the result into lines of fixed size line_len = 80 result = [] start = 0 while 1: if start >= len(val): break result.append(val[start:start + line_len]) start = start + line_len return result class PingPackageUpload(connection.PackageUpload): user_agent = "rhnpush-ping" def ping(self): self.send_http("GET") # return the header info as well to check for capabilities. return self._response.status, self._response.reason, self._response.msg 07070100000015000081B40000000000000000000000015FC8E0A60000060D000000000000000000000000000000000000001300000000mgr-push/rhnpushrc#This is the default config file for rhnpush. Place it in your home directory. [rhnpush] #Only push the packages that are newer than those on the server newest = 0 #Briefly describe the options usage = 0 #Upload only the header(s) header = 0 #Only print the packages that would otherwise have been pushed test = 0 #Use the null org id nullorg = 0 #Upload source package information source = 0 #Read the package names from stdin stdin = 0 #Increase verbosity verbose = 0 #Force the package upload (overwrites if already uploaded) force = 0 #Push unsigned packages nosig = 0 #Only list the specified channels list = 0 #Exclude the packages that match this glob expression exclude = files = #Organization ID orgid = #Relative directory to associate with the package reldir = #Process this number of headers per call count = #Process packages from this directory dir = #Push to this server (http[s]://<hostname>/APP) server = https://localhost/APP #Manage this channel(s) channel = #Determines how long the cache will last, in seconds cache_lifetime = 600 #Reset the cache new_cache = 0 #Run the extended version of the test extended_test = 0 #Disable the session-token support no_session_caching = 0 #Have rhnpush be tolerant of errors when pushing a large number of packages. tolerant = 0 #The CA cert used to verify the ssl server ca_chain = /usr/share/rhn/RHN-ORG-TRUSTED-SSL-CERT #Default connection timeout, (no value for default) timeout = 300 07070100000016000081B40000000000000000000000015FC8E0A6000015AF000000000000000000000000000000000000001400000000mgr-push/rpm2mpm.py# # Copyright (c) 2008--2016 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # import sys import time # pylint: disable=F0401 from uyuni.common import rhn_rpm, rhn_mpm from uyuni.common.usix import ListType, TupleType def main(): packages = sys.argv[1:] if not packages: return for pkgfile in packages: # Try to open the package as a patch first with open(pkgfile) as f: header = rhn_rpm.get_package_header(file_obj=f) p = rpm_to_mpm(header, f) dest_filename = _compute_filename(p.header) print("Writing out the package to %s" % dest_filename) with open(dest_filename, "w+") as dest_file: p.write(dest_file) def _compute_filename(hdr): return '%s-%s.%s.mpm' % (hdr['name'], hdr['version'], hdr['arch']) def rpm_to_mpm(header, file_stream): tag_map = { 'package_group': 'group', 'rpm_version': 'rpmversion', 'payload_size': 'archivesize', 'payload_format': 'payloadformat', 'build_host': 'buildhost', 'build_time': 'buildtime', 'source_rpm': 'sourcerpm', } tags = [ 'name', 'epoch', 'version', 'release', 'arch', 'description', 'summary', 'license', 'package_group', 'rpm_version', 'payload_size', 'payload_format', 'build_host', 'build_time', 'cookie', 'vendor', 'source_rpm', 'sigmd5', 'sigpgp', 'siggpg', 'sigsize', ] result = {} for t in tags: tt = tag_map.get(t, t) result[t] = header[tt] # Add files result['files'] = _extract_files(header) # Dependency result['provides'] = _extract_rpm_requires(header) result['requires'] = _extract_rpm_provides(header) result['conflicts'] = _extract_rpm_conflicts(header) result['obsoletes'] = _extract_rpm_obsoletes(header) result['changelog'] = _extract_rpm_changelog(header) # md5sum, package_size file_stream.seek(0, 2) file_size = file_stream.tell() result['package_size'] = file_size is_source = 0 if header.is_source: is_source = 1 result['is_source'] = is_source result['package_type'] = 'rpm' h = rhn_mpm.MPM_Header(result) p = rhn_mpm.MPM_Package() p.header = h p.payload_stream = file_stream return p def _extract_files(header): tag_maps = { 'name': 'filenames', 'device': 'filedevices', 'inode': 'fileinodes', 'file_mode': 'filemodes', 'username': 'fileusername', 'groupname': 'filegroupname', 'rdev': 'filerdevs', 'file_size': 'filesizes', 'mtime': 'filemtimes', 'md5': 'filemd5s', 'linkto': 'filelinktos', 'flags': 'fileflags', 'verifyflags': 'fileverifyflags', 'lang': 'filelangs', } files = _extract_array_fields(header, tag_maps) # Munge the mtime for f in files: f['mtime'] = gmtime(f['mtime']) return files def _extract_rpm_provides(header): tag_maps = { 'name': 'provides', 'version': 'provideversion', 'flags': 'provideflags', } return _extract_array_fields(header, tag_maps) def _extract_rpm_requires(header): tag_maps = { 'name': 'requirename', 'version': 'requireversion', 'flags': 'requireflags', } return _extract_array_fields(header, tag_maps) def _extract_rpm_conflicts(header): tag_maps = { 'name': 'conflictname', 'version': 'conflictversion', 'flags': 'conflictflags', } return _extract_array_fields(header, tag_maps) def _extract_rpm_obsoletes(header): tag_maps = { 'name': 'obsoletename', 'version': 'obsoleteversion', 'flags': 'obsoleteflags', } return _extract_array_fields(header, tag_maps) def _extract_rpm_changelog(header): tag_maps = { 'name': 'changelogname', 'text': 'changelogtext', 'time': 'changelogtime', } cl = _extract_array_fields(header, tag_maps) # Munge the changelog time for c in cl: c['time'] = gmtime(c['time']) return cl def _extract_array_fields(header, tag_maps): # First determine the number of entries key = list(tag_maps.keys())[0] rpmtag = tag_maps.get(key) arr = header[rpmtag] if arr is None: # nothing to do return [] count = len(arr) result = [] for i in range(count): tag_dict = {} for key, rpmtag in tag_maps.items(): arr = header[rpmtag] if not isinstance(arr, (ListType, TupleType)): arr = [arr] tag_dict[key] = arr[i] result.append(tag_dict) return result def gmtime(timestamp): ttuple = time.gmtime(timestamp) return "%d-%02d-%02d %02d:%02d:%02d" % ttuple[:6] if __name__ == '__main__': sys.exit(main() or 0) 07070100000017000041FD0000000000000000000000015FC8E0A600000000000000000000000000000000000000000000000E00000000mgr-push/test07070100000018000081B40000000000000000000000015FC8E0A6000010E7000000000000000000000000000000000000002200000000mgr-push/test/testRhnpushCache.py# # Copyright (c) 2008--2015 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # import unittest import rhnpush_cache import time class UserInfoTestCase(unittest.TestCase): def setUp(self): self.userinfo = rhnpush_cache.UserInfo(5, username='wregglej', password='password') def tearDown(self): self.userinfo = None def testCheckCacheTrue(self): assert self.userinfo.checkCache() == True def testCheckCacheFalse(self): time.sleep(7) assert self.userinfo.checkCache() == False def testSetUsernamePassword(self): self.userinfo = rhnpush_cache.UserInfo(5, username='wregglej', password='password') self.userinfo.setUsernamePassword('aaaa', 'bbbb') assert self.userinfo.username != 'wregglej' and self.userinfo.password != 'password' def testSetUsernamePassword3(self): self.userinfo = rhnpush_cache.UserInfo(5, username='wregglej', password='password') self.userinfo.setUsernamePassword('aaaa', 'bbbb') assert self.userinfo.username == 'aaaa' and self.userinfo.password == 'bbbb' def testGetUsernamePassword(self): self.userinfo = rhnpush_cache.UserInfo(5, username='wregglej', password='password') assert self.userinfo.username == 'wregglej' and self.userinfo.password == 'password' def testIsFresh(self): self.userinfo = rhnpush_cache.UserInfo(5, username='wregglej', password='password') assert self.userinfo.isFresh() == True def testIsntFresh(self): time.sleep(6) assert self.userinfo.isFresh() == False def testSetCacheLifetime(self): self.userinfo = rhnpush_cache.UserInfo(5, username='wregglej', password='password') self.userinfo.setCacheLifetime(6667) assert self.userinfo.cache_lifetime != 5 and self.userinfo.cache_lifetime == 6667 def testGetTimeLeft(self): self.userinfo = rhnpush_cache.UserInfo(10, username='wregglej', password='password') time.sleep(2.0) assert self.userinfo.getTimeLeft() >= 7.98 and self.userinfo.getTimeLeft() <= 8.002 class CacheManagerTestCase(unittest.TestCase): def setUp(self): self.cache = rhnpush_cache.CacheManager(5) def tearDown(self): self.cache = None def testIsFresh(self): self.cache = rhnpush_cache.CacheManager(5) self.cache.setUsernamePassword('a', 'b') assert self.cache.isFresh() == True def testIsntFresh(self): self.cache = rhnpush_cache.CacheManager(5) time.sleep(7) assert self.cache.isFresh() == False def testSetUsernamePassword(self): self.cache = rhnpush_cache.CacheManager(5) self.cache.setUsernamePassword('wregglej', 'password') # print self.cache.cache.username assert self.cache.cache.username == 'wregglej' and self.cache.cache.password == 'password' def testSetUsernamePassword2(self): self.cache = rhnpush_cache.CacheManager(5) self.cache.setUsernamePassword('wregglej', 'password') self.cache.setUsernamePassword('aaaa', 'bbbb') assert self.cache.cache.username == 'aaaa' and self.cache.cache.password == 'bbbb' def testGetUsernamePassword(self): self.cache = rhnpush_cache.CacheManager(5) self.cache.setUsernamePassword('wregglej', 'password') u, p = self.cache.getUsernamePassword() assert u == 'wregglej' and p == 'password' def testSetCacheLifetime(self): self.cache = rhnpush_cache.CacheManager(5) self.cache.setCacheLifetime(10) assert self.cache.cache.cache_lifetime == 10 and self.cache.cache.cache_lifetime != 5 def testWriteCache(self): pass def testGetTimeLeft(self): pass if __name__ == "__main__": unittest.main() 07070100000019000081B40000000000000000000000015FC8E0A6000007E0000000000000000000000000000000000000002300000000mgr-push/test/testRhnpushConfig.py# # Copyright (c) 2008--2016 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # import rhnpush_config import unittest # pylint: disable=W0212,E1101,R0904 class RhnConfigTestCase(unittest.TestCase): def setUp(self): self.userconfig = rhnpush_config.rhnpushConfigParser('.rhnpushrc') self.defaultconfig = rhnpush_config.rhnpushConfigParser('/etc/sysconfig/rhn/rhnpushrc') def tearDown(self): self.userconfig = None self.defaultconfig = None def testReadConfigFiles(self): self.userconfig._read_config_files() self.defaultconfig._read_config_files() assert self.userconfig.settings != None and self.defaultconfig.settings != None def testGetOption(self): a = self.userconfig.get_option('usage') b = self.defaultconfig.get_option('usage') assert a != None and b != None and a == '0' and b == '0' def testKeys(self): a = list(self.userconfig.keys()) b = list(self.defaultconfig.keys()) assert a != None and b != None def test_keys(self): a = self.userconfig._keys() b = self.defaultconfig._keys() assert a != None and b != None def testGetItem(self): pass def testAddConfigAsAttr(self): self.userconfig._add_config_as_attr() self.userconfig._add_config_as_attr() assert self.userconfig.usage != None and self.defaultconfig.usage != None if __name__ == "__main__": unittest.main() 0707010000001A000081B40000000000000000000000015FC8E0A6000007C9000000000000000000000000000000000000001B00000000mgr-push/test/testUtils.py# # Copyright (c) 2008--2016 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # import unittest import utils class TestObj1: def __init__(self): self.a = 1 self.b = 2 self.c = 3 self._d = '1' self._e = '2' @staticmethod def _private_function(): print("This is privatei to TestObj1 instances") @staticmethod def public_function(): print("This is public and belongs to TestObj1") class TestObj2: def __init__(self): self.a = 4 self.b = 5 self.c = 6 self._d = '4' self._e = '5' self.f = 'aaa' @staticmethod def _private_function(): print("This is private to TestObj2 instances") @staticmethod def public_function(): print("This is public and belongs to TestObj2") class UtilsTestCase(unittest.TestCase): def setUp(self): self.obj1 = TestObj1() self.obj2 = TestObj2() def tearDown(self): self.obj1 = None self.obj2 = None # pylint: disable=W0212 def testMakeCommonAttrEqual(self): self.obj1, self.obj2 = utils.make_common_attr_equal(self.obj1, self.obj2) assert (self.obj1._d == '1' and self.obj2._d == '4' and self.obj1.a == 4 and self.obj1.b == 5 and self.obj1.c == 6 and self.obj2.f == 'aaa') if __name__ == "__main__": unittest.main() 0707010000001B000081B40000000000000000000000015FC8E0A600000A9F000000000000000000000000000000000000001E00000000mgr-push/test/test_archive.py# # Copyright (c) 2008--2015 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # import os import unittest import zipfile # test import import archive # globals ---------------------------------------------------------------- TEST_ARCHIVE = "/tmp/test_archive.zip" TEST_DIR = "./test_archive/foo/bar" TEST_FILE = "test_file" TEST_FILE_PATH = os.path.join(TEST_DIR, TEST_FILE) TEST_CONTENTS = """ ONE: foo TWO: you THREE: too FOUR: foo """ # test case -------------------------------------------------------------- class ArchiveTest(unittest.TestCase): def setUp(self): if not os.path.isdir(TEST_DIR): os.makedirs(TEST_DIR) fd = open(TEST_FILE_PATH, 'w') fd.write(TEST_CONTENTS) fd.close() fzip = zipfile.ZipFile(TEST_ARCHIVE, 'w') fzip.write(TEST_FILE_PATH) fzip.close() def tearDown(self): if os.path.isfile(TEST_FILE_PATH): os.unlink(TEST_FILE_PATH) if os.path.isdir(TEST_DIR): os.removedirs(TEST_DIR) if os.path.isfile(TEST_ARCHIVE): os.unlink(TEST_ARCHIVE) # test methods ------------------------------------------------------- @staticmethod def testInstantiation(): "test the instantiation of an archive parser object" p = archive.get_archive_parser(TEST_ARCHIVE) assert isinstance(p, archive.ArchiveParser) @staticmethod def testFind(): "test the ability of the parser to find a file in the archive" p = archive.get_archive_parser(TEST_ARCHIVE) assert p.contains(TEST_FILE) @staticmethod def testFindPath(): "test the ability of the parser to find a subpath in the archive" p = archive.get_archive_parser(TEST_ARCHIVE) assert p.contains("foo/bar/" + TEST_FILE) @staticmethod def testRead(): "test the ability of the parser to read a file in the archive" p = archive.get_archive_parser(TEST_ARCHIVE) contents = p.read(TEST_FILE) assert contents == TEST_CONTENTS # run the tests ---------------------------------------------------------- if __name__ == "__main__": unittest.main() 0707010000001C000081B40000000000000000000000015FC8E0A60000687F000000000000000000000000000000000000001600000000mgr-push/uploadLib.py# # Copyright (c) 2008--2017 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # # system imports import os import sys import fnmatch import getpass # imports # pylint: disable=F0401,E0611 # exceptions # pylint: disable=W0702,W0703 import inspect from uyuni.common import rhn_mpm from uyuni.common.rhn_pkg import package_from_filename, get_package_header from uyuni.common.usix import raise_with_tb from up2date_client import rhnserver from rhn.i18n import sstr from rhnpush import rhnpush_cache if sys.version_info[0] == 3: import xmlrpc.client as xmlrpclib else: import xmlrpclib try: from rhn import rpclib # pylint: disable=C0412 Binary = rpclib.xmlrpclib.Binary Output = rpclib.transports.Output except ImportError: # old-style xmlrpclib library rpclib = xmlrpclib Binary = rpclib.Binary # pylint: disable=F0401 import cgiwrap Output = cgiwrap.Output # Buffer size we use for copying BUFFER_SIZE = 65536 HEADERS_PER_CALL = 25 # Exception class class UploadError(Exception): pass class ServerFault(Exception): def __init__(self, faultCode=None, faultString="", faultExplanation=""): Exception.__init__(self) self.faultCode = faultCode self.faultString = faultString self.faultExplanation = faultExplanation class UploadClass: """Functionality for an uploading tool """ def __init__(self, options, files=None): self.options = options self.username = None self.password = None self.proxy = None self.proxyUsername = None self.proxyPassword = None self.ca_chain = None self.force = None self.files = files or [] self.new_sat = None self.url = None self.channels = None self.count = None self.server = None self.session = None self.orgId = None self.relativeDir = None self.use_session = True self.use_checksum_paths = False def warn(self, verbose, *args): if self.options.verbose >= verbose: ReportError(*args) @staticmethod def die(errcode, *args): ReportError(*args) # pkilambi:bug#176358:this should exit with error code sys.exit(errcode) def setURL(self): # Redefine this in derived classes self.url = None def setUsernamePassword(self): # Use the stored values, if available username = self.username or self.options.username password = self.password or self.options.password self.username, self.password = getUsernamePassword(username, password) def setProxyUsernamePassword(self): self.proxyUsername = None self.proxyPassword = None def setCAchain(self): self.ca_chain = self.options.ca_chain def setProxy(self): if self.options.proxy is None or self.options.proxy == '': self.proxy = None else: self.proxy = "http://%s" % self.options.proxy def setForce(self): self.force = None def setServer(self): # set the proxy self.setProxy() if self.proxy is None: self.warn(1, "Connecting to %s" % self.url) else: self.warn(1, "Connecting to %s (via proxy '%s')" % (self.url, self.proxy)) # set the CA chain self.setCAchain() # set the proxy username and password self.setProxyUsernamePassword() self.server = getServer(self.url, self.proxy, self.proxyUsername, self.proxyPassword, self.ca_chain) # Compress the output, just to be fast self.server.set_transport_flags( transfer=Output.TRANSFER_BINARY, encoding=Output.ENCODE_GZIP) def setChannels(self): if not self.options.channel: self.die(-1, "No channel was specified") self.channels = self.options.channel self.warn(1, "Channels: %s" % ' '.join(self.channels)) setNoChannels = setChannels def setOrg(self): self.orgId = -1 def setCount(self): if not self.options.count: self.count = HEADERS_PER_CALL else: self.count = self.options.count def setRelativeDir(self): self.relativeDir = None def directory(self): self.warn(2, "Uploading files from directory", self.options.dir) for filename in listdir(self.options.dir): # only add packages if filename[-3:] in ("rpm", "mpm"): self.files.append(filename) def filter_excludes(self): if not self.options.exclude: return self for f in self.files[:]: bf = os.path.basename(f) for pattern in self.options.exclude: if fnmatch.fnmatch(bf, pattern): self.warn(1, "Ignoring %s" % f) self.files.remove(f) return self def readStdin(self): self.warn(1, "Reading package names from stdin") self.files = self.files + readStdin() def _listChannelSource(self): if self.use_session: return listChannelSourceBySession(self.server, self.session.getSessionString(), self.channels) return listChannelSource(self.server, self.username, self.password, self.channels) def _listChannel(self): if self.use_session: if self.use_checksum_paths: return listChannelChecksumBySession(self.server, self.session.getSessionString(), self.channels) return listChannelBySession(self.server, self.session.getSessionString(), self.channels) if self.use_checksum_paths: return listChannelChecksum(self.server, self.username, self.password, self.channels) return listChannel(self.server, self.username, self.password, self.channels) def list(self): # set the URL self.setURL() # set the channels self.setChannels() # set the server self.setServer() self.authenticate() if self.options.source: channel_list = self._listChannelSource() else: # List the channel's contents channel_list = self._listChannel() for p in channel_list: print(p[:6]) def newest(self): # set the URL self.setURL() # set the channels self.setChannels() # set the server self.setServer() self.authenticate() sources = self.options.source if sources: return self.get_missing_source_packages() return self.get_newest_binary_packages() def get_newest_binary_packages(self): # Loop through the args and only keep the newest ones localPackagesHash = {} for filename in self.files: nvrea = self._processFile(filename, nosig=1)['nvrea'] name = nvrea[0] if name not in localPackagesHash: localPackagesHash[name] = {nvrea: filename} continue same_names_hash = localPackagesHash[name] # Already saw this name if nvrea in same_names_hash: # Already seen this nvrea continue skip_rpm = 0 for local_nvrea in same_names_hash.keys(): # XXX is_mpm should be set accordingly ret = packageCompare(local_nvrea, nvrea, is_mpm=0) if ret == 0 and local_nvrea[4] == nvrea[4]: # Weird case, we've already compared the two skip_rpm = 1 break if ret > 0: # nvrea is older than local_nvrea skip_rpm = 1 break if ret < 0: # nvrea is newer than local_nvrea del same_names_hash[local_nvrea] # Different arches - go on if skip_rpm: # Older continue same_names_hash[nvrea] = filename # Now get the list from the server pkglist = self._listChannel() for p in pkglist: name = p[0] if name not in localPackagesHash: # Not in the local list continue same_names_hash = localPackagesHash[name] remote_nvrea = tuple(p[:5]) if remote_nvrea in same_names_hash: # The same package is already uploaded del same_names_hash[remote_nvrea] continue for local_nvrea in list(same_names_hash.keys()): # XXX is_mpm sould be set accordingly ret = packageCompare(local_nvrea, remote_nvrea, is_mpm=0) if ret < 0: # The remote package is newer than the local one del same_names_hash[local_nvrea] continue if ret == 0 and local_nvrea[4] == remote_nvrea[4]: # Same arch del same_names_hash[local_nvrea] continue # This means local is newer # Return the list of files to push l = [] for fhash in localPackagesHash.values(): for filename in fhash.values(): l.append(filename) l.sort() self.files = l def _listMissingSourcePackages(self): if self.use_session: return listMissingSourcePackagesBySession(self.server, self.session.getSessionString(), self.channels) return listMissingSourcePackages(self.server, self.username, self.password, self.channels) def get_missing_source_packages(self): localPackagesHash = {} for filename in self.files: localPackagesHash[os.path.basename(filename)] = filename # Now get the list from the server pkglist = self._listMissingSourcePackages() to_push = [] for pkg in pkglist: pkg_name, _pkg_channel = pkg[:2] if pkg_name not in localPackagesHash: # We don't have it continue to_push.append(localPackagesHash[pkg_name]) to_push.sort() self.files = to_push return self.files def test(self): # Test only for p in self.files: print(p) def _get_files(self): return self.files[:] def _uploadSourcePackageInfo(self, info): if self.use_session: return call(self.server.packages.uploadSourcePackageInfoBySession, self.session.getSessionString(), info) return call(self.server.packages.uploadSourcePackageInfo, self.username, self.password, info) def _uploadPackageInfo(self, info): if self.use_session: return call(self.server.packages.uploadPackageInfoBySession, self.session.getSessionString(), info) return call(self.server.packages.uploadPackageInfo, self.username, self.password, info) def uploadHeaders(self): # Set the forcing factor self.setForce() # Relative directory self.setRelativeDir() # Set the count self.setCount() # set the org self.setOrg() # set the URL self.setURL() # set the channels self.setNoChannels() # set the server self.setServer() self.authenticate() source = self.options.source file_list = self._get_files() while file_list: chunk = file_list[:self.count] del file_list[:self.count] uploadedPackages, headersList = self._processBatch(chunk, relativeDir=self.relativeDir, source=self.options.source, verbose=self.options.verbose, nosig=self.options.nosig) if not headersList: # Nothing to do here... continue # Send the big hash info = {'packages': headersList} if self.orgId > 0 or self.orgId == '': info['orgId'] = self.orgId if self.force: info['force'] = self.force if self.channels: info['channels'] = self.channels # Some feedback if self.options.verbose: ReportError("Uploading batch:") for p in list(uploadedPackages.values())[0]: ReportError("\t\t%s" % p) if source: ret = self._uploadSourcePackageInfo(info) else: ret = self._uploadPackageInfo(info) if ret is None: self.die(-1, "Upload attempt failed") # Append the package information alreadyUploaded, newPackages = ret pkglists = (alreadyUploaded, newPackages) for idx, item in enumerate(pkglists): for p in item: key = tuple(p[:5]) if key not in uploadedPackages: # XXX Hmm self.warn(1, "XXX XXX %s" % str(p)) filename, checksum = uploadedPackages[key] # Some debugging if self.options.verbose: if idx == 0: pattern = "Already uploaded: %s" else: pattern = "Uploaded: %s" print(pattern % filename) # Per-package post actions # For backwards-compatibility with old spacewalk-proxy try: self.processPackage(p, filename, checksum) except TypeError: self.processPackage(p, filename) def processPackage(self, package, filename, checksum=None): pass def checkSession(self, session): return call(self.server.packages.check_session, session) def readSession(self): # pylint: disable=W0703 try: self.session = rhnpush_cache.RHNPushSession() self.session.readSession() except Exception: self.session = None def writeSession(self, session): if self.session: self.session.setSessionString(session) else: self.session = rhnpush_cache.RHNPushSession() self.session.setSessionString(session) if not self.options.no_session_caching: self.session.writeSession() def authenticate(self): # Only use the session token stuff if we're talking to a sat that supports session-token authentication. self.readSession() if self.session and not self.options.new_cache and self.options.username == self.username: chksession = self.checkSession(self.session.getSessionString()) if chksession: return self.setUsernamePassword() sessstr = call(self.server.packages.login, self.username, self.password) self.writeSession(sessstr) # set whether we should use checksum paths or not (if upstream supports # it we should). self.use_checksum_paths = hasChannelChecksumCapability(self.server) @staticmethod def _processFile(filename, relativeDir=None, source=None, nosig=None): """ Processes a file Returns a hash containing: header packageSize checksum relativePath nvrea """ # Is this a file? if not os.access(filename, os.R_OK): raise UploadError("Could not stat the file %s" % filename) if not os.path.isfile(filename): raise UploadError("%s is not a file" % filename) # Size size = os.path.getsize(filename) try: a_pkg = package_from_filename(filename) a_pkg.read_header() a_pkg.payload_checksum() assert a_pkg.header except: raise_with_tb(UploadError("%s is not a valid package" % filename), sys.exc_info()[2]) if nosig is None and not a_pkg.header.is_signed(): raise UploadError("ERROR: %s: unsigned rpm (use --nosig to force)" % filename) # Get the name, version, release, epoch, arch lh = [] for k in ['name', 'version', 'release', 'epoch']: if k == 'epoch' and not a_pkg.header[k]: # Fix the epoch lh.append(sstr("")) else: lh.append(sstr(a_pkg.header[k])) if source: lh.append('src') else: lh.append(sstr(a_pkg.header['arch'])) # Build the header hash to be sent info = {'header': Binary(a_pkg.header.unload()), 'checksum_type': a_pkg.checksum_type, 'checksum': a_pkg.checksum, 'packageSize': size, 'header_start': a_pkg.header_start, 'header_end': a_pkg.header_end} if relativeDir: # Append the relative dir too info["relativePath"] = "%s/%s" % (relativeDir, os.path.basename(filename)) info['nvrea'] = tuple(lh) return info def _processBatch(self, batch, relativeDir, source, verbose, nosig=None): sentPackages = {} headersList = [] for filename in batch: if verbose: print("Uploading %s" % filename) info = self._processFile(filename, relativeDir=relativeDir, source=source, nosig=nosig) # Get nvrea nvrea = info['nvrea'] del info['nvrea'] sentPackages[nvrea] = (filename, info['checksum']) # Append the header to the list of headers to be sent out headersList.append(info) return sentPackages, headersList def readStdin(): # Reads the standard input lines and returns a list l = [] while 1: line = sys.stdin.readline() if not line: break l.append(line.strip()) return l def getUsernamePassword(cmdlineUsername, cmdlinePassword): # Returns a username and password (either by returning the ones passed as # args, or the user's input if cmdlineUsername and cmdlinePassword: return cmdlineUsername, cmdlinePassword username = cmdlineUsername password = cmdlinePassword # Read the username, if not already specified tty = open("/dev/tty", "w") tty.write("SUSE Manager username: ") tty.close() tty = open("/dev/tty", "r") while not username: try: username = tty.readline() except KeyboardInterrupt: tty.write("\n") sys.exit(0) if username is None: # EOF tty.write("\n") sys.exit(0) username = username.strip() if username: break # Now read the password while not password: try: password = getpass.getpass("SUSE Manager password: ") except KeyboardInterrupt: tty.write("\n") sys.exit(0) tty.close() return username, password def listdir(directory): directory = os.path.abspath(os.path.normpath(directory)) if not os.access(directory, os.R_OK | os.X_OK): raise UploadError("Cannot read from directory %s" % directory) if not os.path.isdir(directory): raise UploadError("%s not a directory" % directory) # Build the package list packagesList = [] for f in os.listdir(directory): packagesList.append("%s/%s" % (directory, f)) return packagesList def call(function, *params, **kwargs): # Wrapper function try: ret = function(*params) except xmlrpclib.Fault: e = sys.exc_info()[1] x = parseXMLRPCfault(e) if x.faultString: print(x.faultString) if x.faultExplanation: print(x.faultExplanation) sys.exit(-1) except xmlrpclib.ProtocolError: e = sys.exc_info()[1] if kwargs.get('raise_protocol_error'): raise print(e.errmsg) sys.exit(-1) return ret def parseXMLRPCfault(fault): if not isinstance(fault, xmlrpclib.Fault): return None faultCode = fault.faultCode if faultCode and isinstance(faultCode, type(1)): faultCode = -faultCode return ServerFault(faultCode, "", fault.faultString) # pylint: disable=C0103 def listChannel(server, username, password, channels): return call(server.packages.listChannel, channels, username, password) def listChannelChecksum(server, username, password, channels): return call(server.packages.listChannelChecksum, channels, username, password) def listChannelBySession(server, session_string, channels): return call(server.packages.listChannelBySession, channels, session_string) def listChannelChecksumBySession(server, session_string, channels): return call(server.packages.listChannelChecksumBySession, channels, session_string) def listChannelSource(server, username, password, channels): return call(server.packages.listChannelSource, channels, username, password) def listChannelSourceBySession(server, session_string, channels): return call(server.packages.listChannelSourceBySession, channels, session_string) def listMissingSourcePackages(server, username, password, channels): return call(server.packages.listMissingSourcePackages, channels, username, password) def listMissingSourcePackagesBySession(server, session_string, channels): return call(server.packages.listMissingSourcePackagesBySession, channels, session_string) def getPackageChecksumBySession(server, session_string, info): return call(server.packages.getPackageChecksumBySession, session_string, info) def getSourcePackageChecksumBySession(server, session_string, info): return call(server.packages.getSourcePackageChecksumBySession, session_string, info) def getSourcePackageChecksum(server, username, password, info): return call(server.packages.getSourcePackageChecksum, username, password, info) # for backward compatibility with satellite <5.4.0 def getPackageMD5sumBySession(server, session_string, info): return call(server.packages.getPackageMD5sumBySession, session_string, info) def getSourcePackageMD5sumBySession(server, session_string, info): return call(server.packages.getSourcePackageMD5sumBySession, session_string, info) def getServer(uri, proxy=None, username=None, password=None, ca_chain=None): s = rpclib.Server(uri, proxy=proxy, username=username, password=password) if ca_chain: s.add_trusted_cert(ca_chain) return s # pylint: disable=E1123 def hasChannelChecksumCapability(rpc_server): """ check whether server supports getPackageChecksumBySession function""" # pylint: disable=W1505 if 'rpcServerOverride' in inspect.getargspec(rhnserver.RhnServer.__init__)[0]: server = rhnserver.RhnServer(rpcServerOverride=rpc_server) else: server = rhnserver.RhnServer() # pylint: disable=W0212 server._server = rpc_server return server.capabilities.hasCapability('xmlrpc.packages.checksums') def exists_getPackageChecksumBySession(rpc_server): """ check whether server supports getPackageChecksumBySession function""" # unfortunatelly we do not have capability for getPackageChecksumBySession function, # but extended_profile in version 2 has been created just 2 months before # getPackageChecksumBySession lets use it instead # pylint: disable=W1505 if 'rpcServerOverride' in inspect.getargspec(rhnserver.RhnServer.__init__)[0]: server = rhnserver.RhnServer(rpcServerOverride=rpc_server) else: server = rhnserver.RhnServer() # pylint: disable=W0212 server._server = rpc_server return server.capabilities.hasCapability('xmlrpc.packages.extended_profile', 2) # compare two package [n,v,r,e] tuples def packageCompare(pkg1, pkg2, is_mpm=None): if pkg1[0] != pkg2[0]: raise ValueError("You should only compare packages with the same name") packages = [] for pkg in (pkg1, pkg2): e = pkg[3] if e == "": e = None elif e is not None: e = str(e) evr = (e, str(pkg[1]), str(pkg[2])) packages.append(evr) if is_mpm: func = rhn_mpm.labelCompare else: from uyuni.common import rhn_rpm func = rhn_rpm.labelCompare return func(packages[0], packages[1]) # returns a header from a package file on disk. def get_header(filename, fildes=None, source=None): try: h = get_package_header(filename=filename, fd=fildes) except: raise_with_tb(UploadError("Package is invalid"), sys.exc_info()[2]) # Verify that this is indeed a binary/source. xor magic # xor doesn't work with None values, so compare the negated values - the # results are identical if (not source) ^ (not h.is_source): raise UploadError("Unexpected RPM package type") return h def ReportError(*args): sys.stderr.write(' '.join(map(str, args)) + "\n") 0707010000001D000081B40000000000000000000000015FC8E0A600000B4C000000000000000000000000000000000000001200000000mgr-push/utils.py# # Copyright (c) 2008--2017 Red Hat, Inc. # # This software is licensed to you under the GNU General Public License, # version 2 (GPLv2). There is NO WARRANTY for this software, express or # implied, including the implied warranties of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 # along with this software; if not, see # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. # # Red Hat trademarks are not licensed under GPLv2. No permission is # granted to use or replicate Red Hat trademarks that are incorporated # in this software or its documentation. # import os import pwd import sys def get_home_dir(): userid = os.getuid() info = pwd.getpwuid(userid) return info[5] # If Object1 and Object2 have any common attributes, set the attribute in Object1 # to the value of the attribute in Object2. Does not make functions or variables starting with '_' equivalent. def make_common_attr_equal(object1, object2): # Go through every attribute in object1 for attr in object1.__dict__.keys(): # Make sure that the attribute name doesn't begin with "_" if len(attr) < 1 or attr[0] == "_": continue # Make sure that object2 has the attribute as well. and that it's not equal to ''. if attr not in object2.__dict__ or object2.__dict__[attr] == '': continue # Make sure the attributes are the same type OR that the attribute in object1 is None. if isinstance(object1.__dict__[attr], (type(object2.__dict__[attr]), type(None))): if object1.__dict__[attr] != object2.__dict__[attr]: object1.__dict__[attr] = object2.__dict__[attr] else: continue else: continue return (object1, object2) # Pylint is too stupid to understand subclasses of tuples apparently. # This is just to make it shut up. def tupleify_urlparse(urlparse_object): ret = [] if hasattr(urlparse_object, 'scheme'): ret.append(urlparse_object.scheme) ret.append(urlparse_object.netloc) ret.append(urlparse_object.path) ret.append(urlparse_object.params) ret.append(urlparse_object.query) ret.append(urlparse_object.fragment) else: ret = [urlparse_object[i] for i in range(0, 6)] if sys.version_info[0] == 3: for i in range(0, 6): if not isinstance(ret[i], str): ret[i] = ret[i].decode('ascii') return tuple(ret) if __name__ == "__main__": # This is just for testing purposes. # pylint: disable=R0903 class class1: def __init__(self): self.a = "aaaa" class class2: def __init__(self): self.a = 1 obj1 = class1() obj2 = class2() obj1, obj2 = make_common_attr_equal(obj1, obj2) print(obj1.a) print(obj2.a) 07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
