Cài đặt nhiều tệp deb trong khi tôn trọng các phụ thuộc của chúng

Để hỗ trợ cài đặt ngoại tuyến nhiều .debtệp, tôi đang sử dụng:

sudo dpkg -i dependencies/*.deb

Tôi đã nhận thấy một số gói không sử dụng phương thức này vì thứ tự chúng đã cài đặt

Ví dụ, đây là những gì xảy ra khi tôi cài đặt mariadb-server-5.5và các phụ thuộc của nó:

Làm thế nào tôi có thể cài đặt *.debcác tập tin trong khi tôn trọng sự phụ thuộc của họ?

• Tôi đang cố gắng tránh thiết lập một repo cục bộ, vì nó khó bảo trì hơn.
• Như một cách giải quyết, tôi chạy lệnh dpkg -i *.debhai lần.

Bạn có thể thử với -R và cài đặt tùy chọn:

sudo dpkg -R --install dependencies/

-R Recursive xử lý tất cả các tệp thông thường khớp với mẫu * .deb được tìm thấy tại các thư mục cụ thể và tất cả các thư mục con của nó

Sắp xếp cấu trúc liên kết (thông qua tập lệnh)

Lệnh này có vấn đề - không tuân thủ đúng các gói đặt hàng nên được cài đặt (ngay cả khi bạn cung cấp tất cả các gói bắt buộc).dpkg -i packages/*.deb

Tập lệnh tùy chỉnh để cai trị tất cả

Theo giả định, bản phân phối debian của bạn đã cài đặt python (của tôi là Ubuntu 14.04 LTS và đi kèm python27)

Ngoài packagesthư mục .deb ngoại tuyến , hãy cung cấp một tập lệnh;

• Trích xuất siêu dữ liệu và Topo sắp xếp tất cả các gói ứng cử viên
• Sử dụng dpkg -iđể cài đặt các gói được sắp xếp theo đúng thứ tự chúng nên được cài đặt

Ví dụ: thực hiện lệnh này để cài đặt tất cả các gói ngoại tuyến được thu thập trước

sudo python install.py

• Cấu trúc thư mục của bạn sẽ trông như thế này

  

cài đặt

#!/usr/bin/env python

import os
import re
import subprocess
import logging

import sys

rootLogger = logging.getLogger()
rootLogger.setLevel(logging.INFO)
consoleHandler = logging.StreamHandler(sys.stdout)
consoleHandler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
rootLogger.addHandler(consoleHandler)

SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))


class TopologicalSort(object):
    def __init__(self, dependency_map):
        self._dependency_map = dependency_map
        self._already_processed = set()

    def _get_dependencies(self, item, root=None):

        if not root:
            root = item

        elif root == item:
            logging.warn("circular dependency detected in '{}'".format(item))
            raise StopIteration()

        dependencies = self._dependency_map.get(item, [])
        for dependency in dependencies:

            if dependency in self._already_processed:
                continue

            self._already_processed.add(dependency)

            for sub_dependency in self._get_dependencies(dependency, root=root):
                yield sub_dependency

            yield dependency

    def sort(self):
        # Reduction, connect all nodes to a dummy node and re-calculate
        special_package_id = 'topological-sort-special-node'
        self._dependency_map[special_package_id] = self._dependency_map.keys()
        sorted_dependencies = self._get_dependencies(special_package_id)
        sorted_dependencies = list(sorted_dependencies)
        del self._dependency_map[special_package_id]

        # Remove "noise" dependencies (only referenced, not declared)
        sorted_dependencies = filter(lambda x: x in self._dependency_map, sorted_dependencies)
        return sorted_dependencies


class DebianPackage(object):
    def __init__(self, file_path):
        metadata = subprocess.check_output('dpkg -I {}'.format(file_path), shell=True)
        metadata = metadata.replace('\n ', '\n')
        self._metadata = metadata
        self.id = self._get('Package')
        self.dependencies = list(self._get_dependencies())
        self.file_path = file_path

    def _get_dependencies(self):
        dependencies = self._get('Depends') + ',' + self._get('Pre-Depends')
        dependencies = re.split(r',|\|', dependencies)
        dependencies = map(lambda x: re.sub(r'\(.*\)|:any', '', x).strip(), dependencies)
        dependencies = filter(lambda x: x, dependencies)
        dependencies = set(dependencies)
        for dependency in dependencies:
            yield dependency

    def _get(self, key):
        search = re.search(r'\n{key}:(.*)\n[A-Z]'.format(key=key), self._metadata)
        return search.group(1).strip() if search else ''


def sort_debian_packages(directory_path):
    file_names = os.listdir(directory_path)
    debian_packages = {}
    dependency_map = {}
    for file_name in file_names:

        file_path = os.path.join(directory_path, file_name)

        if not os.path.isfile(file_path):
            continue

        debian_package = DebianPackage(file_path)
        debian_packages[debian_package.id] = debian_package
        dependency_map[debian_package.id] = debian_package.dependencies

    sorted_dependencies = TopologicalSort(dependency_map).sort()
    sorted_dependencies = map(lambda package_id: debian_packages[package_id].file_path, sorted_dependencies)
    return sorted_dependencies


def main():
    # ------------------
    # Sort the packages using topological sort

    packages_dir_path = os.path.join(SCRIPT_DIR, 'packages')
    logging.info('sorting packages in "{}" using topological sort ...'.format(packages_dir_path))
    sorted_packages = sort_debian_packages(packages_dir_path)

    # ------------------
    # Install the packages in the sorted order

    for index, package_file_path in enumerate(sorted_packages):
        command = 'dpkg -i {}'.format(package_file_path)
        logging.info('executing "{}" ...'.format(command))
        subprocess.check_call(command, shell=True)


if __name__ == '__main__':

    if os.geteuid() != 0:
        logging.error('must be run as root')
        sys.exit(1)

    try:
        main()
    except:
        logging.error('failed to install packages', exc_info=True)
        sys.exit(1)