264 lines
8.4 KiB
Python
Executable File
264 lines
8.4 KiB
Python
Executable File
#!/usr/bin/python
|
|
|
|
"""Copyright 2011 Gentoo Foundation
|
|
Distributed under the terms of the GNU General Public License v2
|
|
"""
|
|
|
|
from __future__ import print_function
|
|
|
|
""" Meta """
|
|
__author__ = "Corentin Chary (iksaif)"
|
|
__email__ = "corentin.chary@gmail.com"
|
|
__version__ = "git"
|
|
__productname__ = "euscan"
|
|
__description__ = "A tool to detect new upstream releases."
|
|
__version__ = "git"
|
|
|
|
""" Imports """
|
|
|
|
import sys
|
|
import getopt
|
|
import errno
|
|
import httplib
|
|
|
|
from portage.output import white, yellow, turquoise, green, EOutput
|
|
from portage.exception import AmbiguousPackageName
|
|
|
|
from gentoolkit import pprinter as pp
|
|
from gentoolkit.eclean.search import (port_settings)
|
|
from gentoolkit.errors import GentoolkitException
|
|
|
|
import euscan
|
|
from euscan import CONFIG
|
|
from euscan.scan import scan_upstream
|
|
|
|
""" Globals """
|
|
|
|
|
|
def setupSignals():
|
|
""" This block ensures that ^C interrupts are handled quietly. """
|
|
import signal
|
|
|
|
def exithandler(signum, frame):
|
|
signal.signal(signal.SIGINT, signal.SIG_IGN)
|
|
signal.signal(signal.SIGTERM, signal.SIG_IGN)
|
|
print()
|
|
sys.exit(errno.EINTR)
|
|
|
|
signal.signal(signal.SIGINT, exithandler)
|
|
signal.signal(signal.SIGTERM, exithandler)
|
|
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
|
|
|
|
|
|
def printVersion():
|
|
"""Output the version info."""
|
|
print("%s (%s) - %s" \
|
|
% (__productname__, __version__, __description__))
|
|
print()
|
|
print("Author: %s <%s>" % (__author__, __email__))
|
|
print("Copyright 2011 Gentoo Foundation")
|
|
print("Distributed under the terms of the GNU General Public License v2")
|
|
|
|
|
|
def printUsage(_error=None, help=None):
|
|
"""Print help message. May also print partial help to stderr if an
|
|
error from {'options'} is specified."""
|
|
|
|
out = sys.stdout
|
|
if _error:
|
|
out = sys.stderr
|
|
if not _error in ('global-options', 'packages',):
|
|
_error = None
|
|
if not _error and not help:
|
|
help = 'all'
|
|
if _error in ('global-options',):
|
|
print(pp.error("Wrong option on command line."), file=out)
|
|
print(file=out)
|
|
if _error in ('packages',):
|
|
print(pp.error("You need to specify exactly one package."), file=out)
|
|
print(file=out)
|
|
print(white("Usage:"), file=out)
|
|
if _error in ('global-options', 'packages',) or help == 'all':
|
|
print(" " + turquoise(__productname__),
|
|
yellow("[options]"),
|
|
green("<package> [<package> [...]]"), file=out)
|
|
if _error in ('global-options',) or help == 'all':
|
|
print(" " + turquoise(__productname__),
|
|
yellow("[--help, --version]"), file=out)
|
|
|
|
print(file=out)
|
|
if _error in ('global-options',) or help:
|
|
print("Available ", yellow("options") + ":", file=out)
|
|
print(yellow(" -C, --nocolor") +
|
|
" - turn off colors on output", file=out)
|
|
print(yellow(" -q, --quiet") +
|
|
" - be as quiet as possible", file=out)
|
|
print(yellow(" -h, --help") +
|
|
" - display the help screen", file=out)
|
|
print(yellow(" -V, --version") +
|
|
" - display version info", file=out)
|
|
print(file=out)
|
|
print(yellow(" -1, --oneshot") +
|
|
" - stop as soon as a new version is found",
|
|
file=out)
|
|
print(yellow(" -b, --brute-force=<level>") +
|
|
" - define the brute force " + yellow("<level>") +
|
|
" (default: 2)\n" +
|
|
" " * 29 + "bigger levels will generate more versions numbers\n" +
|
|
" " * 29 + "0 means disabled", file=out)
|
|
print(file=out)
|
|
if _error in ('packages',) or help:
|
|
print(green(" package") +
|
|
" - the packages (or ebuilds) you want to scan",
|
|
file=out)
|
|
print(file=out)
|
|
'''print( "More detailed instruction can be found in",
|
|
turquoise("`man %s`" % __productname__), file=out)'''
|
|
|
|
|
|
class ParseArgsException(Exception):
|
|
"""For parseArgs() -> main() communications."""
|
|
def __init__(self, value):
|
|
self.value = value
|
|
|
|
def __str__(self):
|
|
return repr(self.value)
|
|
|
|
|
|
def parseArgs():
|
|
"""Parse the command line arguments. Raise exceptions on
|
|
errors. Returns package and affect the CONFIG dict.
|
|
"""
|
|
|
|
def optionSwitch(opts):
|
|
"""local function for interpreting command line options
|
|
and setting options accordingly"""
|
|
return_code = True
|
|
for o, a in opts:
|
|
if o in ("-h", "--help"):
|
|
raise ParseArgsException('help')
|
|
elif o in ("-V", "--version"):
|
|
raise ParseArgsException('version')
|
|
elif o in ("-C", "--nocolor"):
|
|
CONFIG['nocolor'] = True
|
|
pp.output.nocolor()
|
|
elif o in ("-q", "--quiet"):
|
|
CONFIG['quiet'] = True
|
|
CONFIG['verbose'] = 0
|
|
elif o in ("-1", "--oneshot"):
|
|
CONFIG['oneshot'] = True
|
|
elif o in ("-b", "--brute-force"):
|
|
CONFIG['brute-force'] = int(a)
|
|
elif o in ("-v", "--verbose") and not CONFIG['quiet']:
|
|
CONFIG['verbose'] += 1
|
|
else:
|
|
return_code = False
|
|
|
|
return return_code
|
|
|
|
' here are the different allowed command line options (getopt args) '
|
|
getopt_options = {'short': {}, 'long': {}}
|
|
getopt_options['short']['global'] = "hVCqv1b:"
|
|
getopt_options['long']['global'] = ["help", "version", "nocolor", "quiet",
|
|
"verbose", "oneshot", "brute-force="]
|
|
|
|
short_opts = getopt_options['short']['global']
|
|
long_opts = getopt_options['long']['global']
|
|
opts_mode = 'global'
|
|
|
|
' apply getopts to command line, show partial help on failure '
|
|
try:
|
|
opts, args = getopt.getopt(sys.argv[1:], short_opts, long_opts)
|
|
except:
|
|
raise ParseArgsException(opts_mode + '-options')
|
|
|
|
' set options accordingly '
|
|
optionSwitch(opts)
|
|
|
|
if len(args) < 1:
|
|
raise ParseArgsException('packages')
|
|
|
|
return args
|
|
|
|
|
|
def main():
|
|
"""Parse command line and execute all actions."""
|
|
CONFIG['nocolor'] = (port_settings["NOCOLOR"] in ('yes', 'true')
|
|
or not sys.stdout.isatty())
|
|
if CONFIG['nocolor']:
|
|
pp.output.nocolor()
|
|
' parse command line options and actions '
|
|
try:
|
|
packages = parseArgs()
|
|
except ParseArgsException as e:
|
|
if e.value == 'help':
|
|
printUsage(help='all')
|
|
sys.exit(0)
|
|
elif e.value[:5] == 'help-':
|
|
printUsage(help=e.value[5:])
|
|
sys.exit(0)
|
|
elif e.value == 'version':
|
|
printVersion()
|
|
sys.exit(0)
|
|
else:
|
|
printUsage(e.value)
|
|
sys.exit(errno.EINVAL)
|
|
|
|
""" Change euscan's output """
|
|
euscan.output = EOutput(CONFIG['quiet'])
|
|
if CONFIG['verbose'] > 2:
|
|
httplib.HTTPConnection.debuglevel = 1
|
|
|
|
for package in packages:
|
|
ret = []
|
|
|
|
try:
|
|
ret = scan_upstream(package)
|
|
except AmbiguousPackageName as e:
|
|
pkgs = e.args[0]
|
|
for candidate in pkgs:
|
|
print(candidate)
|
|
|
|
from os.path import basename # To get the short name
|
|
|
|
print(file=sys.stderr)
|
|
print(
|
|
pp.error(
|
|
"The short ebuild name '%s' is ambiguous. Please specify" \
|
|
% basename(pkgs[0])
|
|
),
|
|
file=sys.stderr, end=""
|
|
)
|
|
pp.die(1, "one of the above fully-qualified ebuild names instead.")
|
|
except GentoolkitException as err:
|
|
pp.die(1, '%s: %s' % (package, str(err)))
|
|
except Exception as err:
|
|
pp.die(1, '%s: %s' % (package, str(err)))
|
|
|
|
if not CONFIG['quiet']:
|
|
print()
|
|
|
|
for cp, url, version in ret:
|
|
if not CONFIG['quiet']:
|
|
print("Upstream Version: "
|
|
+ pp.number("%s" % version)
|
|
+ pp.path(" %s" % url))
|
|
else:
|
|
print(pp.cpv("%s-%s" % (cp, version))
|
|
+ ": " + pp.path(url))
|
|
|
|
if not len(ret) and not CONFIG['quiet']:
|
|
print(pp.warn("Didn't find any new version, "
|
|
+ "check package's homepage for "
|
|
+ "more informations"))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
setupSignals()
|
|
main()
|
|
except KeyboardInterrupt:
|
|
print("Aborted.")
|
|
sys.exit(errno.EINTR)
|
|
sys.exit(0)
|