wic: Remove rpmmisc

wic doesn't use it, so remove it.

(From OE-Core rev: a49b39ddf18b1b058c0a892e1a7450239eea66ce)

Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

1 files changed, 0 insertions, 600 deletions

diff --git a/scripts/lib/mic/utils/rpmmisc.py b/scripts/lib/mic/utils/rpmmisc.py
deleted file mode 100644
index af15763e18..0000000000
--- a/scripts/lib/mic/utils/rpmmisc.py
+++ /dev/null
@@ -1,600 +0,0 @@
-#!/usr/bin/python -tt
-#
-# Copyright (c) 2008, 2009, 2010, 2011 Intel, Inc.
-#
-# 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; version 2 of the License
-#
-# 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., 59
-# Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-import os
-import sys
-import re
-import rpm
-
-from mic import msger
-from mic.utils.errors import CreatorError
-from mic.utils.proxy import get_proxy_for
-from mic.utils import runner
-
-
-class RPMInstallCallback:
-    """ Command line callback class for callbacks from the RPM library.
-    """
-
-    def __init__(self, ts, output=1):
-        self.output = output
-        self.callbackfilehandles = {}
-        self.total_actions = 0
-        self.total_installed = 0
-        self.installed_pkg_names = []
-        self.total_removed = 0
-        self.mark = "+"
-        self.marks = 40
-        self.lastmsg = None
-        self.tsInfo = None # this needs to be set for anything else to work
-        self.ts = ts
-        self.filelog = False
-        self.logString = []
-        self.headmsg = "Installing"
-
-    def _dopkgtup(self, hdr):
-        tmpepoch = hdr['epoch']
-        if tmpepoch is None: epoch = '0'
-        else: epoch = str(tmpepoch)
-
-        return (hdr['name'], hdr['arch'], epoch, hdr['version'], hdr['release'])
-
-    def _makeHandle(self, hdr):
-        handle = '%s:%s.%s-%s-%s' % (hdr['epoch'], hdr['name'], hdr['version'],
-          hdr['release'], hdr['arch'])
-
-        return handle
-
-    def _localprint(self, msg):
-        if self.output:
-            msger.info(msg)
-
-    def _makefmt(self, percent, progress = True):
-        l = len(str(self.total_actions))
-        size = "%s.%s" % (l, l)
-        fmt_done = "[%" + size + "s/%" + size + "s]"
-        done = fmt_done % (self.total_installed + self.total_removed,
-                           self.total_actions)
-        marks = self.marks - (2 * l)
-        width = "%s.%s" % (marks, marks)
-        fmt_bar = "%-" + width + "s"
-        if progress:
-            bar = fmt_bar % (self.mark * int(marks * (percent / 100.0)), )
-            fmt = "\r  %-10.10s: %-20.20s " + bar + " " + done
-        else:
-            bar = fmt_bar % (self.mark * marks, )
-            fmt = "  %-10.10s: %-20.20s "  + bar + " " + done
-        return fmt
-
-    def _logPkgString(self, hdr):
-        """return nice representation of the package for the log"""
-        (n,a,e,v,r) = self._dopkgtup(hdr)
-        if e == '0':
-            pkg = '%s.%s %s-%s' % (n, a, v, r)
-        else:
-            pkg = '%s.%s %s:%s-%s' % (n, a, e, v, r)
-
-        return pkg
-
-    def callback(self, what, bytes, total, h, user):
-        if what == rpm.RPMCALLBACK_TRANS_START:
-            if bytes == 6:
-                self.total_actions = total
-
-        elif what == rpm.RPMCALLBACK_TRANS_PROGRESS:
-            pass
-
-        elif what == rpm.RPMCALLBACK_TRANS_STOP:
-            pass
-
-        elif what == rpm.RPMCALLBACK_INST_OPEN_FILE:
-            self.lastmsg = None
-            hdr = None
-            if h is not None:
-                try:
-                    hdr, rpmloc = h
-                except:
-                    rpmloc = h
-                    hdr = readRpmHeader(self.ts, h)
-
-                handle = self._makeHandle(hdr)
-                fd = os.open(rpmloc, os.O_RDONLY)
-                self.callbackfilehandles[handle]=fd
-                if hdr['name'] not in self.installed_pkg_names:
-                    self.installed_pkg_names.append(hdr['name'])
-                    self.total_installed += 1
-                return fd
-            else:
-                self._localprint("No header - huh?")
-
-        elif what == rpm.RPMCALLBACK_INST_CLOSE_FILE:
-            hdr = None
-            if h is not None:
-                try:
-                    hdr, rpmloc = h
-                except:
-                    rpmloc = h
-                    hdr = readRpmHeader(self.ts, h)
-
-                handle = self._makeHandle(hdr)
-                os.close(self.callbackfilehandles[handle])
-                fd = 0
-
-                # log stuff
-                #pkgtup = self._dopkgtup(hdr)
-                self.logString.append(self._logPkgString(hdr))
-
-        elif what == rpm.RPMCALLBACK_INST_PROGRESS:
-            if h is not None:
-                percent = (self.total_installed*100L)/self.total_actions
-                if total > 0:
-                    try:
-                        hdr, rpmloc = h
-                    except:
-                        rpmloc = h
-
-                    m = re.match("(.*)-(\d+.*)-(\d+\.\d+)\.(.+)\.rpm", os.path.basename(rpmloc))
-                    if m:
-                        pkgname = m.group(1)
-                    else:
-                        pkgname = os.path.basename(rpmloc)
-                if self.output:
-                    fmt = self._makefmt(percent)
-                    msg = fmt % (self.headmsg, pkgname)
-                    if msg != self.lastmsg:
-                        self.lastmsg = msg
-
-                        msger.info(msg)
-
-                        if self.total_installed == self.total_actions:
-                            msger.raw('')
-                            msger.verbose('\n'.join(self.logString))
-
-        elif what == rpm.RPMCALLBACK_UNINST_START:
-            pass
-
-        elif what == rpm.RPMCALLBACK_UNINST_PROGRESS:
-            pass
-
-        elif what == rpm.RPMCALLBACK_UNINST_STOP:
-            self.total_removed += 1
-
-        elif what == rpm.RPMCALLBACK_REPACKAGE_START:
-            pass
-
-        elif what == rpm.RPMCALLBACK_REPACKAGE_STOP:
-            pass
-
-        elif what == rpm.RPMCALLBACK_REPACKAGE_PROGRESS:
-            pass
-
-def readRpmHeader(ts, filename):
-    """ Read an rpm header. """
-
-    fd = os.open(filename, os.O_RDONLY)
-    h = ts.hdrFromFdno(fd)
-    os.close(fd)
-    return h
-
-def splitFilename(filename):
-    """ Pass in a standard style rpm fullname
-
-        Return a name, version, release, epoch, arch, e.g.::
-            foo-1.0-1.i386.rpm returns foo, 1.0, 1, i386
-            1:bar-9-123a.ia64.rpm returns bar, 9, 123a, 1, ia64
-    """
-
-    if filename[-4:] == '.rpm':
-        filename = filename[:-4]
-
-    archIndex = filename.rfind('.')
-    arch = filename[archIndex+1:]
-
-    relIndex = filename[:archIndex].rfind('-')
-    rel = filename[relIndex+1:archIndex]
-
-    verIndex = filename[:relIndex].rfind('-')
-    ver = filename[verIndex+1:relIndex]
-
-    epochIndex = filename.find(':')
-    if epochIndex == -1:
-        epoch = ''
-    else:
-        epoch = filename[:epochIndex]
-
-    name = filename[epochIndex + 1:verIndex]
-    return name, ver, rel, epoch, arch
-
-def getCanonX86Arch(arch):
-    #
-    if arch == "i586":
-        f = open("/proc/cpuinfo", "r")
-        lines = f.readlines()
-        f.close()
-        for line in lines:
-            if line.startswith("model name") and line.find("Geode(TM)") != -1:
-                return "geode"
-        return arch
-    # only athlon vs i686 isn't handled with uname currently
-    if arch != "i686":
-        return arch
-
-    # if we're i686 and AuthenticAMD, then we should be an athlon
-    f = open("/proc/cpuinfo", "r")
-    lines = f.readlines()
-    f.close()
-    for line in lines:
-        if line.startswith("vendor") and line.find("AuthenticAMD") != -1:
-            return "athlon"
-        # i686 doesn't guarantee cmov, but we depend on it
-        elif line.startswith("flags") and line.find("cmov") == -1:
-            return "i586"
-
-    return arch
-
-def getCanonX86_64Arch(arch):
-    if arch != "x86_64":
-        return arch
-
-    vendor = None
-    f = open("/proc/cpuinfo", "r")
-    lines = f.readlines()
-    f.close()
-    for line in lines:
-        if line.startswith("vendor_id"):
-            vendor = line.split(':')[1]
-            break
-    if vendor is None:
-        return arch
-
-    if vendor.find("Authentic AMD") != -1 or vendor.find("AuthenticAMD") != -1:
-        return "amd64"
-    if vendor.find("GenuineIntel") != -1:
-        return "ia32e"
-    return arch
-
-def getCanonArch():
-    arch = os.uname()[4]
-
-    if (len(arch) == 4 and arch[0] == "i" and arch[2:4] == "86"):
-        return getCanonX86Arch(arch)
-
-    if arch == "x86_64":
-        return getCanonX86_64Arch(arch)
-
-    return arch
-
-# Copy from libsatsolver:poolarch.c, with cleanup
-archPolicies = {
-    "x86_64":       "x86_64:i686:i586:i486:i386",
-    "i686":         "i686:i586:i486:i386",
-    "i586":         "i586:i486:i386",
-    "ia64":         "ia64:i686:i586:i486:i386",
-    "armv7tnhl":    "armv7tnhl:armv7thl:armv7nhl:armv7hl",
-    "armv7thl":     "armv7thl:armv7hl",
-    "armv7nhl":     "armv7nhl:armv7hl",
-    "armv7hl":      "armv7hl",
-    "armv7l":       "armv7l:armv6l:armv5tejl:armv5tel:armv5l:armv4tl:armv4l:armv3l",
-    "armv6l":       "armv6l:armv5tejl:armv5tel:armv5l:armv4tl:armv4l:armv3l",
-    "armv5tejl":    "armv5tejl:armv5tel:armv5l:armv4tl:armv4l:armv3l",
-    "armv5tel":     "armv5tel:armv5l:armv4tl:armv4l:armv3l",
-    "armv5l":       "armv5l:armv4tl:armv4l:armv3l",
-}
-
-# dict mapping arch -> ( multicompat, best personality, biarch personality )
-multilibArches = {
-    "x86_64":  ( "athlon", "x86_64", "athlon" ),
-}
-
-# from yumUtils.py
-arches = {
-    # ia32
-    "athlon": "i686",
-    "i686": "i586",
-    "geode": "i586",
-    "i586": "i486",
-    "i486": "i386",
-    "i386": "noarch",
-
-    # amd64
-    "x86_64": "athlon",
-    "amd64": "x86_64",
-    "ia32e": "x86_64",
-
-    # arm
-    "armv7tnhl": "armv7nhl",
-    "armv7nhl": "armv7hl",
-    "armv7hl": "noarch",
-    "armv7l": "armv6l",
-    "armv6l": "armv5tejl",
-    "armv5tejl": "armv5tel",
-    "armv5tel": "noarch",
-
-    #itanium
-    "ia64": "noarch",
-}
-
-def isMultiLibArch(arch=None):
-    """returns true if arch is a multilib arch, false if not"""
-    if arch is None:
-        arch = getCanonArch()
-
-    if not arches.has_key(arch): # or we could check if it is noarch
-        return False
-
-    if multilibArches.has_key(arch):
-        return True
-
-    if multilibArches.has_key(arches[arch]):
-        return True
-
-    return False
-
-def getBaseArch():
-    myarch = getCanonArch()
-    if not arches.has_key(myarch):
-        return myarch
-
-    if isMultiLibArch(arch=myarch):
-        if multilibArches.has_key(myarch):
-            return myarch
-        else:
-            return arches[myarch]
-
-    if arches.has_key(myarch):
-        basearch = myarch
-        value = arches[basearch]
-        while value != 'noarch':
-            basearch = value
-            value = arches[basearch]
-
-        return basearch
-
-def checkRpmIntegrity(bin_rpm, package):
-    return runner.quiet([bin_rpm, "-K", "--nosignature", package])
-
-def checkSig(ts, package):
-    """ Takes a transaction set and a package, check it's sigs,
-        return 0 if they are all fine
-        return 1 if the gpg key can't be found
-        return 2 if the header is in someway damaged
-        return 3 if the key is not trusted
-        return 4 if the pkg is not gpg or pgp signed
-    """
-
-    value = 0
-    currentflags = ts.setVSFlags(0)
-    fdno = os.open(package, os.O_RDONLY)
-    try:
-        hdr = ts.hdrFromFdno(fdno)
-
-    except rpm.error, e:
-        if str(e) == "public key not availaiable":
-            value = 1
-        if str(e) == "public key not available":
-            value = 1
-        if str(e) == "public key not trusted":
-            value = 3
-        if str(e) == "error reading package header":
-            value = 2
-    else:
-        error, siginfo = getSigInfo(hdr)
-        if error == 101:
-            os.close(fdno)
-            del hdr
-            value = 4
-        else:
-            del hdr
-
-    try:
-        os.close(fdno)
-    except OSError:
-        pass
-
-    ts.setVSFlags(currentflags) # put things back like they were before
-    return value
-
-def getSigInfo(hdr):
-    """ checks signature from an hdr hand back signature information and/or
-        an error code
-    """
-
-    import locale
-    locale.setlocale(locale.LC_ALL, 'C')
-
-    string = '%|DSAHEADER?{%{DSAHEADER:pgpsig}}:{%|RSAHEADER?{%{RSAHEADER:pgpsig}}:{%|SIGGPG?{%{SIGGPG:pgpsig}}:{%|SIGPGP?{%{SIGPGP:pgpsig}}:{(none)}|}|}|}|'
-    siginfo = hdr.sprintf(string)
-    if siginfo != '(none)':
-        error = 0
-        sigtype, sigdate, sigid = siginfo.split(',')
-    else:
-        error = 101
-        sigtype = 'MD5'
-        sigdate = 'None'
-        sigid = 'None'
-
-    infotuple = (sigtype, sigdate, sigid)
-    return error, infotuple
-
-def checkRepositoryEULA(name, repo):
-    """ This function is to check the EULA file if provided.
-        return True: no EULA or accepted
-        return False: user declined the EULA
-    """
-
-    import tempfile
-    import shutil
-    import urlparse
-    import urllib2 as u2
-    import httplib
-    from mic.utils.errors import CreatorError
-
-    def _check_and_download_url(u2opener, url, savepath):
-        try:
-            if u2opener:
-                f = u2opener.open(url)
-            else:
-                f = u2.urlopen(url)
-        except u2.HTTPError, httperror:
-            if httperror.code in (404, 503):
-                return None
-            else:
-                raise CreatorError(httperror)
-        except OSError, oserr:
-            if oserr.errno == 2:
-                return None
-            else:
-                raise CreatorError(oserr)
-        except IOError, oserr:
-            if hasattr(oserr, "reason") and oserr.reason.errno == 2:
-                return None
-            else:
-                raise CreatorError(oserr)
-        except u2.URLError, err:
-            raise CreatorError(err)
-        except httplib.HTTPException, e:
-            raise CreatorError(e)
-
-        # save to file
-        licf = open(savepath, "w")
-        licf.write(f.read())
-        licf.close()
-        f.close()
-
-        return savepath
-
-    def _pager_file(savepath):
-
-        if os.path.splitext(savepath)[1].upper() in ('.HTM', '.HTML'):
-            pagers = ('w3m', 'links', 'lynx', 'less', 'more')
-        else:
-            pagers = ('less', 'more')
-
-        file_showed = False
-        for pager in pagers:
-            cmd = "%s %s" % (pager, savepath)
-            try:
-                os.system(cmd)
-            except OSError:
-                continue
-            else:
-                file_showed = True
-                break
-
-        if not file_showed:
-            f = open(savepath)
-            msger.raw(f.read())
-            f.close()
-            msger.pause()
-
-    # when proxy needed, make urllib2 follow it
-    proxy = repo.proxy
-    proxy_username = repo.proxy_username
-    proxy_password = repo.proxy_password
-
-    if not proxy:
-        proxy = get_proxy_for(repo.baseurl[0])
-
-    handlers = []
-    auth_handler = u2.HTTPBasicAuthHandler(u2.HTTPPasswordMgrWithDefaultRealm())
-    u2opener = None
-    if proxy:
-        if proxy_username:
-            proxy_netloc = urlparse.urlsplit(proxy).netloc
-            if proxy_password:
-                proxy_url = 'http://%s:%s@%s' % (proxy_username, proxy_password, proxy_netloc)
-            else:
-                proxy_url = 'http://%s@%s' % (proxy_username, proxy_netloc)
-        else:
-            proxy_url = proxy
-
-        proxy_support = u2.ProxyHandler({'http': proxy_url,
-                                         'https': proxy_url,
-                                         'ftp': proxy_url})
-        handlers.append(proxy_support)
-
-    # download all remote files to one temp dir
-    baseurl = None
-    repo_lic_dir = tempfile.mkdtemp(prefix = 'repolic')
-
-    for url in repo.baseurl:
-        tmphandlers = handlers[:]
-
-        (scheme, host, path, parm, query, frag) = urlparse.urlparse(url.rstrip('/') + '/')
-        if scheme not in ("http", "https", "ftp", "ftps", "file"):
-            raise CreatorError("Error: invalid url %s" % url)
-
-        if '@' in host:
-            try:
-                user_pass, host = host.split('@', 1)
-                if ':' in user_pass:
-                    user, password = user_pass.split(':', 1)
-            except ValueError, e:
-                raise CreatorError('Bad URL: %s' % url)
-
-            msger.verbose("adding HTTP auth: %s, XXXXXXXX" %(user))
-            auth_handler.add_password(None, host, user, password)
-            tmphandlers.append(auth_handler)
-            url = scheme + "://" + host + path + parm + query + frag
-
-        if tmphandlers:
-            u2opener = u2.build_opener(*tmphandlers)
-
-        # try to download
-        repo_eula_url = urlparse.urljoin(url, "LICENSE.txt")
-        repo_eula_path = _check_and_download_url(
-                                u2opener,
-                                repo_eula_url,
-                                os.path.join(repo_lic_dir, repo.id + '_LICENSE.txt'))
-        if repo_eula_path:
-            # found
-            baseurl = url
-            break
-
-    if not baseurl:
-        shutil.rmtree(repo_lic_dir) #cleanup
-        return True
-
-    # show the license file
-    msger.info('For the software packages in this yum repo:')
-    msger.info('    %s: %s' % (name, baseurl))
-    msger.info('There is an "End User License Agreement" file that need to be checked.')
-    msger.info('Please read the terms and conditions outlined in it and answer the followed qustions.')
-    msger.pause()
-
-    _pager_file(repo_eula_path)
-
-    # Asking for the "Accept/Decline"
-    if not msger.ask('Would you agree to the terms and conditions outlined in the above End User License Agreement?'):
-        msger.warning('Will not install pkgs from this repo.')
-        shutil.rmtree(repo_lic_dir) #cleanup
-        return False
-
-    # try to find support_info.html for extra infomation
-    repo_info_url = urlparse.urljoin(baseurl, "support_info.html")
-    repo_info_path = _check_and_download_url(
-                            u2opener,
-                            repo_info_url,
-                            os.path.join(repo_lic_dir, repo.id + '_support_info.html'))
-    if repo_info_path:
-        msger.info('There is one more file in the repo for additional support information, please read it')
-        msger.pause()
-        _pager_file(repo_info_path)
-
-    #cleanup
-    shutil.rmtree(repo_lic_dir)
-    return True