Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
dhwp	[ DIR ]	drwxr-xr-x
zabbix	[ DIR ]	drwxr-xr-x
bulkexec	1.24 MB	-rwxr-xr-x
cache-url	3.72 KB	-rwxr-xr-x
dib-init-system	25 B	-rwxrwxr-x
extract-image	8.21 KB	-rwxr-xr-x
install-packages	2.07 KB	-rwxr-xr-x
lc-housekeeper	4.33 MB	-rwxr-xr-x
logchomper	6.84 MB	-rwxr-xr-x
logchomper-api-server	6.75 MB	-rwxr-xr-x
logpipe	2.45 MB	-rwxr-xr-x
logsplitter	449.09 KB	-rwxr-xr-x
node_exporter	19 MB	-rwxr-xr-x
package-installs	1.51 KB	-rwxr-xr-x
package-installs-squash	8.44 KB	-rwxr-xr-x
package-installs-v2	4.8 KB	-rwxr-xr-x
package-uninstalls	1.38 KB	-rwxr-xr-x
php-5.6	8.02 MB	-rwxr-xr-x
php-7.0	8.35 MB	-rwxr-xr-x
php-7.1	8.64 MB	-rwxr-xr-x
php-7.2	9.19 MB	-rwxr-xr-x
php-7.3	9.05 MB	-rwxr-xr-x
php-7.4	10.01 MB	-rwxr-xr-x
php-8.0	10.01 MB	-rwxr-xr-x
php-8.1	10.01 MB	-rwxr-xr-x
php-8.2	12.01 MB	-rwxr-xr-x
php-8.3	12.01 MB	-rwxr-xr-x
php-8.4	12.01 MB	-rwxr-xr-x
php-8.5	16.75 MB	-rwxr-xr-x
phpize-5.6	4.44 KB	-rwxr-xr-x
phpize-7.0	4.46 KB	-rwxr-xr-x
phpize-7.1	4.45 KB	-rwxr-xr-x
phpize-7.2	4.45 KB	-rwxr-xr-x
phpize-7.3	4.47 KB	-rwxr-xr-x
phpize-7.4	4.43 KB	-rwxr-xr-x
phpize-8.0	4.45 KB	-rwxr-xr-x
phpize-8.1	4.45 KB	-rwxr-xr-x
phpize-8.2	4.45 KB	-rwxr-xr-x
phpize-8.3	4.45 KB	-rwxr-xr-x
phpize-8.4	4.76 KB	-rwxr-xr-x
phpize-8.5	4.76 KB	-rwxr-xr-x
pkg-map	6.73 KB	-rwxr-xr-x
redis-accessproxy	17.12 MB	-rwxr-xr-x
smartctl_exporter	16.35 MB	-rwxr-xr-x
yara	36 KB	-rwxr-xr-x
yara-rt-scanner	32.01 MB	-rwxr-xr-x
yarac	22.6 KB	-rwxr-xr-x

Code Editor : package-installs-v2

#!/usr/bin/env python3

# Copyright 2014 Hewlett-Packard Development Company, L.P.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

import argparse
import json
import locale
import os
import subprocess
import sys

from collections import defaultdict

# run a command, return output
#  if follow is set, output will be echoed to stdout
def process_output(cmdline, follow=False):
    proc = subprocess.Popen(cmdline, stdout=subprocess.PIPE,
                            stderr=subprocess.STDOUT)
    if follow:
        print("Running command: %s" % cmdline)
        out = ""
        with proc.stdout:
            for line in iter(proc.stdout.readline, b''):
                line = line.decode(encoding=locale.getpreferredencoding(False),
                                   errors='backslashreplace')
                out += line
                print("> %s" % line, end="")
        proc.wait()
        print("returncode: %d" % proc.returncode)
    else:
        out = proc.communicate()[0].decode(errors='backslashreplace')

if proc.returncode:
        e = subprocess.CalledProcessError(proc.returncode, cmdline)
        e.output = out
        raise e

return out

def main():
    dbg_level = int(os.getenv('DIB_DEBUG_TRACE', '0'))

parser = argparse.ArgumentParser(
        description="Install or uninstall packages for a specific phase based"
                    " on package-installs files.")
    parser.add_argument('--phase', required=True,
                        help="Install phase to filter on. Valid options are"
                             " 'install.d' or pre-install.d")
    parser.add_argument('--uninstall', action="store_true",
                        help="Only show packages to uninstall. By default only"
                             " packages to install are shown")
    parser.add_argument('-n', '--noop', action="store_true",
                        help="Don't actually install, just print the command")
    parser.add_argument('infile', help="File to process")
    args = parser.parse_args()

packages = json.load(open(args.infile))
    if args.uninstall:
        install = "uninstall"
    else:
        install = "install"

pkgs = list()
    if args.phase in packages and install in packages[args.phase]:
        install_packages = packages[args.phase][install]
    else:
        print("Nothing to %s" % install)
        sys.exit(0)

# sort the list by element, this way we only do one pkg-map call
    # per element
    by_element = defaultdict(list)
    for (pkg, element) in install_packages:
        by_element[element].append(pkg)

for element, packages in by_element.items():
        print("Map %s for %s: %s" % (install, element, ', '.join(packages)))

# Only trace pkg-map for higher levels of debugging.  Note
        # that pkg-map debug output comes out on stderr, which is
        # captured into the output by process_output.  We filter by
        # "prefix" so we don't think the debug lines are packages!
        pkg_map_args = ['pkg-map', '--prefix', '-',
                        '--missing-ok', '--element', element]
        if dbg_level > 1:
            pkg_map_args.append('--debug')
        pkg_map_args.extend(packages)

try:
            follow = True if dbg_level > 1 else False
            map_output = process_output(pkg_map_args, follow=follow)
            map_output = map_output.strip().split('\n')
            map_output = [m[1:] for m in map_output if m.startswith('-')]
            pkgs.extend(map_output)
        except subprocess.CalledProcessError as e:
            if e.returncode == 1:
                if args.noop:
                    pkgs.append(pkg)
                    continue
                else:
                    print("pkg-map failed")
                    sys.exit(1)
            elif e.returncode == 2:
                pkgs.append(pkg)
                continue

install_args = ["install-packages"]
    if args.uninstall:
        install_args.append("-e")
    install_args.extend(list(set(pkgs)))

if args.noop:
        print(" ".join(install_args))
    else:
        try:
            process_output(install_args, follow=True)
        except subprocess.CalledProcessError as e:
            print("install-packages failed with returncode %d" % e.returncode)
            sys.exit(1)

if __name__ == '__main__':
    main()

# Tell emacs to use python-mode
# Local variables:
# mode: python
# End:

${this.title}

Code Editor : package-installs-v2