Graybyt3 Was Here

Linux host1.absolutelystunningcenterpieces.com 3.10.0-957.21.3.el7.x86_64 #1 SMP Tue Jun 18 16:35:19 UTC 2019 x86_64
Apache
69.167.136.200

File Name : proxies.py

import os
import logging
import report

import problem.config

class DBusProxy(object):
    __instance = None

def __init__(self, dbus):
        self._proxy = None
        self._iface = None
        self.dbus = dbus
        self.connected = False
        self.connect()

def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(DBusProxy, cls).__new__(cls)

return cls.__instance

def connect(self):
        self.connected = False
        if self._proxy:
            self._proxy.close()
        try:
            self._proxy = self.dbus.SystemBus().get_object(
                'org.freedesktop.problems', '/org/freedesktop/problems')
        except self.dbus.exceptions.DBusException as e:
            logging.debug('Unable to get dbus proxy: {0}'.format(e))
            return

try:
            self._iface = self.dbus.Interface(self._proxy,
                                              'org.freedesktop.problems')
        except self.dbus.exceptions.DBusException as e:
            logging.debug('Unable to get dbus interface: {0}'.format(e))
            return

self.connected = True

def _dbus_call(self, fun_name, *args):
        try:
            logging.debug('Calling {0} with {1}'.format(fun_name, args))
            return getattr(self._iface, fun_name)(*args)
        except self.dbus.exceptions.DBusException as e:
            dbname = e.get_dbus_name()
            if dbname == "org.freedesktop.DBus.Error.ServiceUnknown":
                self.connect()
                return getattr(self._iface, fun_name)(*args)

if dbname == 'org.freedesktop.problems.AuthFailure':
                raise problem.exception.AuthFailure(e)

if dbname == 'org.freedesktop.problems.InvalidProblemDir':
                raise problem.exception.InvalidProblem(e)

raise

def get_item(self, dump_dir, name):
        val = self._dbus_call('GetInfo', dump_dir, [name])
        if name not in val:
            return None

return str(val[name])

def set_item(self, dump_dir, name, value):
        return self._dbus_call('SetElement', dump_dir, name, str(value))

def del_item(self, dump_dir, name):
        return self._dbus_call('DeleteElement', dump_dir, name)

def create(self, problem_dict):
        return self._dbus_call('NewProblem', problem_dict)

def delete(self, dump_dir):
        return self._dbus_call('DeleteProblem', [dump_dir])

def list(self):
        return map(str, self._dbus_call('GetProblems'))

def list_all(self):
        return map(str, self._dbus_call('GetAllProblems'))

class SocketProxy(object):
    def create(self, problem_dict):
        import socket
        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        sock.settimeout(5)
        try:
            sock.connect('/var/run/abrt/abrt.socket')
            sock.sendall("PUT / HTTP/1.1\r\n\r\n")
            for key, value in problem_dict.iteritems():
                sock.sendall('{0}={1}\0'.format(key.upper(), value))

sock.shutdown(socket.SHUT_WR)
            resp = ''
            while True:
                buf = sock.recv(256)
                if not buf:
                    break
                resp += buf
            return resp
        except socket.timeout as exc:
            logging.error('communication with daemon failed: {0}'.format(exc))
            return None

def get_item(self, *args):
        raise NotImplementedError

def set_item(self, *args):
        raise NotImplementedError

def del_item(self, *args):
        raise NotImplementedError

def delete(self, *args):
        raise NotImplementedError

def list(self, *args):
        raise NotImplementedError

def list_all(self, *args):
        return self.list(*args)

def get_problem_watcher(self):
        raise NotImplementedError

class FsProxy(object):
    def __init__(self, directory=problem.config.DEFAULT_DUMP_LOCATION):
        self.directory = directory

def create(self, problem_dict):
        probd = report.problem_data()
        for key, value in problem_dict.iteritems():
            probd.add(key, value)

ddir = probd.create_dump_dir(self.directory)
        ret = ddir.name
        ddir.close()
        return ret

def _open_ddir(self, dump_dir, readonly=False):
        flags = 0
        if readonly:
            flags |= report.DD_OPEN_READONLY

ddir = report.dd_opendir(dump_dir, flags)
        if not ddir:
            raise problem.exception.InvalidProblem(
                'Can\'t open directory: {0}'.format(dump_dir))

return ddir

def get_item(self, dump_dir, name):
        ddir = self._open_ddir(dump_dir, readonly=True)

flags = (report.DD_FAIL_QUIETLY_EACCES |
                 report.DD_FAIL_QUIETLY_ENOENT |
                 report.DD_LOAD_TEXT_RETURN_NULL_ON_FAILURE)

val = ddir.load_text(name, flags)

ddir.close()
        return val

def set_item(self, dump_dir, name, value):
        ddir = self._open_ddir(dump_dir)
        ddir.save_text(name, str(value))
        ddir.close()

def del_item(self, dump_dir, name):
        ddir = self._open_ddir(dump_dir)
        ddir.delete_item(name)
        ddir.close()

def delete(self, dump_dir):
        ddir = report.dd_opendir(dump_dir)
        if not ddir:
            return not os.path.isdir(dump_dir)

ddir.delete()
        return True

def list(self, _all=False):
        for dir_entry in os.listdir(self.directory):
            dump_dir = os.path.join(self.directory, dir_entry)

if not os.path.isdir(dump_dir) or not os.access(dump_dir, os.R_OK):
                continue

uid = os.getuid()
            gid = os.getuid()
            dir_stat = os.stat(dump_dir)
            if not _all and (dir_stat.st_uid != uid and
                             dir_stat.st_gid != gid):
                continue

ddir = report.dd_opendir(dump_dir, report.DD_OPEN_READONLY)
            if ddir:
                ddir.close()
                yield dump_dir

def list_all(self, *args, **kwargs):
        kwargs.update(dict(_all=True))
        return self.list(*args, **kwargs)

def get_proxy():
    try:
        import dbus
        wrapper = DBusProxy(dbus)
        if wrapper.connected:
            return wrapper
    except ImportError:
        logging.debug('DBus not found')

return FsProxy()

System Information
*ReClick For Close
File : BlackDragon /wanderfuls/about.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2019-09-26 01:52:09
..	dir	-	root/root	0755	2024-09-19 01:51:26
__init__.py	file	7.51 KB	root/root	0644	2019-08-12 09:18:46
__init__.pyc	file	11.29 KB	root/root	0644	2019-08-12 09:18:52
__init__.pyo	file	11.29 KB	root/root	0644	2019-08-12 09:18:52
_pyabrt.so	file	10.93 KB	root/root	0755	2019-08-12 09:18:52
config.py	file	50 B	root/root	0644	2019-08-12 09:18:46
config.pyc	file	199 B	root/root	0644	2019-08-12 09:18:52
config.pyo	file	199 B	root/root	0644	2019-08-12 09:18:52
exception.py	file	175 B	root/root	0644	2019-08-12 09:18:46
exception.pyc	file	929 B	root/root	0644	2019-08-12 09:18:52
exception.pyo	file	929 B	root/root	0644	2019-08-12 09:18:52
proxies.py	file	6.31 KB	root/root	0644	2019-08-12 09:18:46
proxies.pyc	file	9.3 KB	root/root	0644	2019-08-12 09:18:52
proxies.pyo	file	9.3 KB	root/root	0644	2019-08-12 09:18:52
tools.py	file	546 B	root/root	0644	2019-08-12 09:18:46
tools.pyc	file	775 B	root/root	0644	2019-08-12 09:18:52
tools.pyo	file	775 B	root/root	0644	2019-08-12 09:18:52
watch.py	file	1.91 KB	root/root	0644	2019-08-12 09:18:46
watch.pyc	file	2.66 KB	root/root	0644	2019-08-12 09:18:52
watch.pyo	file	2.66 KB	root/root	0644	2019-08-12 09:18:52