Python system.System类代码示例

	def print_helper(self, app, args):
		if app.instances:
			manager = System.package_manager()
			package = manager.provided_by(app)
			if package:
				package.load_info(System.package_manager())

			tr = Tracer(System.package_manager(), Rules, Applications)
			tr.now = self.args.now
			if self.packages:
				tr.specified_packages = self.packages

			try: affected_by = tr.trace_application(app)
			except AccessDenied: affected_by = _("You don't have enough permissions")
			affects = self._affects(app, affected_by)

			view = HelperView()
			view.assign("args", args)
			view.assign("processes", app.instances)
			view.assign("application", app)
			view.assign("package", package)
			view.assign("affected_by", affected_by)
			view.assign("affects", affects)
			view.render()
		else:
			print(_("Application called {0} is not running").format(app.name))

	def render_packages(self):
		timestamp = self.args.timestamp[0] if self.args.timestamp[0] else System.boot_time()
		manager = System.package_manager()
		packages = manager.packages_newer_than(timestamp)

		view = PackagesView()
		view.assign('packages', packages)
		view.assign('boot_time', System.boot_time())
		view.render()

	def _helper(app):
		if app.type == Applications.TYPES["DAEMON"]:
			if System.init_system() == "systemd" and System.distribution() == "arch":
				return "systemctl restart {0}".format(app.name)
			else:
				return "service {0} restart".format(app.name)

		elif app.type == Applications.TYPES["STATIC"]:
			return _("You will have to reboot your computer")

		elif app.type == Applications.TYPES["SESSION"]:
			return _("You will have to log out & log in again")

		return None

	def _modified_packages(self):
		"""Returns list of packages what tracer should care about"""
		if self.specified_packages and self.now:
			return PackagesCollection(self.specified_packages)

		timestamp = self.timestamp if self.timestamp else System.boot_time()
		packages = self._PACKAGE_MANAGER.packages_newer_than(timestamp)
		packages = packages.intersection(self.specified_packages)
		return packages

	def __init__(self, package_manager, rules, applications, memory=None, hooks_observer=None, erased=False):
		if not package_manager:
			raise UnsupportedDistribution(System.distribution())

		self._PACKAGE_MANAGER = package_manager
		self._rules = rules
		self._applications = applications
		self._memory = memory
		self._hooks_observer = hooks_observer
		self._erased = erased

	def name(self):
		if System.init_system() == "systemd":
			bus = SystemdDbus()
			if self.instances and bus.unit_path_from_pid(self.instances[0].pid):
				if not bus.has_service_property_from_pid(self.instances[0].pid,'PAMName'):
					Id = bus.get_unit_property_from_pid(self.instances[0].pid,'Id')
					if Id and re.search("\.service$", Id):
						return re.sub('\.service$', '', Id)
		if self.is_interpreted:
			return self.instances[0].real_name
		return self._attributes["name"]

	def __init__(self, args, packages):
		self.args = args
		self.tracer = Tracer(
			System.package_manager(erased=args.erased),
			Rules,
			Applications,
			memory=dump_memory,
			hooks_observer=HooksObserver(),
			erased=args.erased
		)
		self.tracer.now = args.now
		self.tracer.timestamp = args.timestamp[0]
		if packages:
			self.tracer.specified_packages = packages

		self.applications = self.tracer.trace_affected(self._user(args.user))
		if self.args.daemons_only:
			self.applications = self.applications.filter_types([Applications.TYPES["DAEMON"]])

	def __init__(self, args, call_helper=None):
		#TODO filter blacklisted packages from restart

		tracer = Tracer(
			System.package_manager(erased=args.erased),
			Rules,
			Applications,
			memory=dump_memory,
			erased=args.erased
		)

		daemons = tracer.trace_affected(user="root").filter_types([Applications.TYPES["DAEMON"]])

		if call_helper is None:
			call_helper = RestartController._call_helper
		else:
			call_helper = call_helper
		self.restarted_daemons = RestartController.restart_daemons(daemons, call_helper)

	def render_system(self):
		uptime = datetime.now() - datetime.fromtimestamp(System.boot_time())
		uptime = str(uptime).split('.')[0]

		users = set([user.name for user in psutil.get_users()])
		package_managers = System.package_manager().names()

		view = SystemView()
		view.assign('python', System.python_version())
		view.assign('distribution', System.distribution())
		view.assign('package_managers', package_managers)
		view.assign('init', System.init_system())
		view.assign('uptime', uptime)
		view.assign('user', System.user())
		view.assign('users', users)
		view.assign('version', __version__)
		view.assign('rules_count', len(Rules.all()))
		view.assign('applications_count', len(Applications.all()))
		view.render()

			return path
	return paths[0]


PROJECT_DIR = dirname(dirname(realpath(__file__)))

DATA_DIR = __([
	PROJECT_DIR + '/' + 'data',
	'/usr/share/tracer',
])

USER_CONFIG_DIRS = [
	'/etc/tracer',
]

HOOKS_DIRS = [
	'/etc/tracer/hooks',
]

LANG_DIR = __([
	PROJECT_DIR + '/build/' + 'locale',
	'/usr/share/locale',
])

try:
	user = System.user()
	USER_CONFIG_DIRS.append(expanduser('~' + user) + '/.config/tracer')
	HOOKS_DIRS.append(expanduser('~' + user) + '/.config/tracer/hooks')
except OSError:
	pass

	def _user(self, user):
		if   user == '*':    return None
		elif user == 'root': return user
		elif not user:       return System.user()
		else: return user[0]

	def is_service(self):
		if System.init_system() == "systemd":
			return SystemdDbus().unit_path_from_id("{0}.service".format(self.name))

	def helper(self):
		helper = self._attributes["helper"] if self._attributes["helper"] else Applications._helper(self)
		if System.user() != "root" and self.type == Applications.TYPES["DAEMON"]:
			if helper and not helper.startswith("sudo "):
				helper = "sudo " + helper
		return helper

# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties 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.
#

from __future__ import absolute_import


from tracer.resources.system import System
if System.distribution() == "debian":

	from .ipackageManager import IPackageManager
	from tracer.resources.package import Package
	from tracer.resources.collections import PackagesCollection
	import subprocess
	import time
	import os

	class Dpkg(IPackageManager):

		"""
		Package manager class - DPKG
		"""

		# noinspection PyMissingConstructor

# Enable importing modules from parent directory (tracer's root directory)
import os
parentdir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
os.sys.path.insert(0, parentdir)

import sys
import platform
import unittest
from tracer.resources.system import System

DISTRO = System.distribution()