def __init__ (self, parent=None, try_as_root=True, lock=False,
host=None, port=None, encryption=None):
if host != None:
cups.setServer (host)
if port != None:
cups.setPort (port)
if encryption != None:
cups.setEncryption (encryption)
self._use_password = ''
self._parent = parent
self._try_as_root = try_as_root
self._use_user = cups.getUser ()
self._server = cups.getServer ()
self._port = cups.getPort()
self._encryption = cups.getEncryption ()
self._prompt_allowed = True
self._operation_stack = []
self._lock = lock
self._gui_event = threading.Event ()
creds = global_authinfocache.lookup_auth_info (host=host, port=port)
if creds != None:
if (creds[0] != 'root' or try_as_root):
(self._use_user, self._use_password) = creds
del creds
self._connect ()
def __init__(self,
parent=None,
try_as_root=True,
lock=False,
host=None,
port=None,
encryption=None):
if host != None:
cups.setServer(host)
if port != None:
cups.setPort(port)
if encryption != None:
cups.setEncryption(encryption)
self._use_password = ''
self._parent = parent
self._try_as_root = try_as_root
self._use_user = cups.getUser()
self._server = cups.getServer()
self._port = cups.getPort()
self._encryption = cups.getEncryption()
self._prompt_allowed = True
self._operation_stack = []
self._lock = lock
self._gui_event = threading.Event()
self._connect()
def print_by_server(doctype, name, print_format=None, doc=None, no_letterhead=0):
print_settings = frappe.get_doc("Print Settings")
try:
import cups
except ImportError:
frappe.throw(_("You need to install pycups to use this feature!"))
return
try:
cups.setServer(print_settings.server_ip)
cups.setPort(print_settings.port)
conn = cups.Connection()
output = PdfFileWriter()
output = frappe.get_print(doctype, name, print_format, doc=doc, no_letterhead=no_letterhead, as_pdf = True, output = output)
file = os.path.join("/", "tmp", "frappe-pdf-{0}.pdf".format(frappe.generate_hash()))
output.write(open(file,"wb"))
conn.printFile(print_settings.printer_name,file , name, {})
except IOError as e:
if ("ContentNotFoundError" in e.message
or "ContentOperationNotPermittedError" in e.message
or "UnknownContentError" in e.message
or "RemoteHostClosedError" in e.message):
frappe.throw(_("PDF generation failed"))
except cups.IPPError:
frappe.throw(_("Printing failed"))
finally:
cleanup(file,{})
def serve(self):
try:
server = self.env.config.get("cups.server")
port = self.env.config.get("cups.port")
user = self.env.config.get("cups.user")
password = self.env.config.get("cups.password")
encryption_policy = getattr(cups, "HTTP_ENCRYPT_%s" % self.env.config.get("cups.encryption-policy",
default="IF_REQUESTED").upper())
if server is not None:
cups.setServer(server)
if port is not None:
cups.setPort(int(port))
if user is not None:
cups.setUser(user)
if encryption_policy is not None:
cups.setEncryption(encryption_policy)
if password is not None:
def pw_callback(prompt):
return password
cups.setPasswordCB(pw_callback)
self.client = cups.Connection()
sched = PluginRegistry.getInstance("SchedulerService").getScheduler()
sched.add_interval_job(self.__gc, minutes=60, tag='_internal', jobstore="ram")
sched.add_interval_job(self.__update_printer_list, minutes=30, tag='_internal', jobstore="ram")
except RuntimeError as e:
self.log.error(str(e))
self.client = None
def get_printers_list(self, ip="localhost", port=631):
printer_list = []
try:
import cups
except ImportError:
frappe.throw(
_("""This feature can not be used as dependencies are missing.
Please contact your system manager to enable this by installing pycups!""")
)
return
try:
cups.setServer(self.server_ip)
cups.setPort(self.port)
conn = cups.Connection()
printers = conn.getPrinters()
for printer_id, printer in printers.items():
printer_list.append({
"value": printer_id,
"label": printer["printer-make-and-model"]
})
except RuntimeError:
frappe.throw(_("Failed to connect to server"))
except frappe.ValidationError:
frappe.throw(_("Failed to connect to server"))
return printer_list
def print_by_server(doctype, name, print_format=None, doc=None, no_letterhead=0):
print_settings = frappe.get_doc("Print Settings")
try:
import cups
except ImportError:
frappe.throw("You need to install pycups to use this feature!")
return
try:
cups.setServer(print_settings.server_ip)
cups.setPort(print_settings.port)
conn = cups.Connection()
output = PdfFileWriter()
output = frappe.get_print(doctype, name, print_format, doc=doc, no_letterhead=no_letterhead, as_pdf = True, output = output)
file = os.path.join("/", "tmp", "frappe-pdf-{0}.pdf".format(frappe.generate_hash()))
output.write(open(file,"wb"))
conn.printFile(print_settings.printer_name,file , name, {})
except IOError as e:
if ("ContentNotFoundError" in e.message
or "ContentOperationNotPermittedError" in e.message
or "UnknownContentError" in e.message
or "RemoteHostClosedError" in e.message):
frappe.throw(_("PDF generation failed"))
except cups.IPPError:
frappe.throw(_("Printing failed"))
finally:
cleanup(file,{})
def collect(self):
"""Collects the metrics from cups
"""
start = time.time()
self._setup_empty_prometheus_metrics()
cups.setServer(self.host)
cups.setPort(self.port)
cups.setUser(self.user)
try:
conn = cups.Connection()
printers = conn.getPrinters()
self._prometheus_metrics['printersNum'].add_metric([],
len(printers))
self._getPrinterStatus(printers)
self._getJobData(conn)
self._prometheus_metrics['cupsUp'].add_metric([], 1)
except Exception as e:
self._prometheus_metrics['cupsUp'].add_metric([], 0)
print(e)
duration = time.time() - start
self._prometheus_metrics['scrape_duration_seconds'].add_metric(
[], duration)
for metric in self._prometheus_metrics.values():
yield metric
def __init__(self,
bus=None,
my_jobs=True,
specific_dests=None,
monitor_jobs=True,
host=None,
port=None,
encryption=None):
GObject.GObject.__init__(self)
self.my_jobs = my_jobs
self.specific_dests = specific_dests
self.monitor_jobs = monitor_jobs
self.jobs = {}
self.printer_state_reasons = {}
self.printers = set()
self.process_pending_events = True
self.fetch_jobs_timer = None
self.cups_connection_in_error = False
if host:
cups.setServer(host)
if port:
cups.setPort(port)
if encryption:
cups.setEncryption(encryption)
self.user = cups.getUser()
self.host = cups.getServer()
self.port = cups.getPort()
self.encryption = cups.getEncryption()
self.ppdcache = ppdcache.PPDCache(host=self.host,
port=self.port,
encryption=self.encryption)
self.which_jobs = "not-completed"
self.reasons_seen = {}
self.connecting_timers = {}
self.still_connecting = set()
self.connecting_to_device = {}
self.received_any_dbus_signals = False
self.update_timer = None
if bus is None:
try:
bus = dbus.SystemBus()
except dbus.exceptions.DBusException:
# System bus not running.
pass
self.bus = bus
if bus is not None:
bus.add_signal_receiver(self.handle_dbus_signal,
path=self.DBUS_PATH,
dbus_interface=self.DBUS_IFACE)
self.sub_id = -1
def __init__(self, bus=None, my_jobs=True,
specific_dests=None, monitor_jobs=True, host=None,
port=None, encryption=None):
GObject.GObject.__init__ (self)
self.my_jobs = my_jobs
self.specific_dests = specific_dests
self.monitor_jobs = monitor_jobs
self.jobs = {}
self.printer_state_reasons = {}
self.printers = set()
self.process_pending_events = True
self.fetch_jobs_timer = None
self.cups_connection_in_error = False
if host:
cups.setServer (host)
if port:
cups.setPort (port)
if encryption:
cups.setEncryption (encryption)
self.user = cups.getUser ()
self.host = cups.getServer ()
self.port = cups.getPort ()
self.encryption = cups.getEncryption ()
self.ppdcache = ppdcache.PPDCache (host=self.host,
port=self.port,
encryption=self.encryption)
self.which_jobs = "not-completed"
self.reasons_seen = {}
self.connecting_timers = {}
self.still_connecting = set()
self.connecting_to_device = {}
self.received_any_dbus_signals = False
self.update_timer = None
if bus is None:
try:
bus = dbus.SystemBus ()
except dbus.exceptions.DBusException:
# System bus not running.
pass
self.bus = bus
if bus is not None:
bus.add_signal_receiver (self.handle_dbus_signal,
path=self.DBUS_PATH,
dbus_interface=self.DBUS_IFACE)
self.sub_id = -1
def _connect (self):
cups.setUser (self._use_user)
cups.setServer (self._server)
cups.setPort (self._port)
self._connection = cups.Connection ()
self._user = self._use_user
debugprint ("Connected as user %s" % self._user)
methodtype = type (self._connection.getPrinters)
for fname in dir (self._connection):
if fname[0] == '_':
continue
fn = getattr (self._connection, fname)
if type (fn) != methodtype:
continue
setattr (self, fname, self._make_binding (fname, fn))
def create(cls, printer=None, server="", port=0, user=""):
"""Return a handle to print using a connection to the (local) CUPS server, if available."""
try:
import cups
except ImportError:
return
cups.setServer(server or "")
cups.setPort(port or 0)
cups.setUser(user or "")
try:
c = cups.Connection()
except RuntimeError:
return
h = cls(c, printer)
if h.printer().printerName() in c.getPrinters():
return h
def get_printers(self,ip="localhost",port=631):
printer_list = []
try:
import cups
except ImportError:
frappe.throw("You need to install pycups to use this feature!")
return
try:
cups.setServer(self.server_ip)
cups.setPort(self.port)
conn = cups.Connection()
printers = conn.getPrinters()
printer_list = printers.keys()
except RuntimeError:
frappe.throw(_("Failed to connect to server"))
except ValidationError:
frappe.throw(_("Failed to connect to server"))
return printer_list
def get_printers(self, ip="localhost", port=631):
printer_list = []
try:
import cups
except ImportError:
frappe.throw(_("You need to install pycups to use this feature!"))
return
try:
cups.setServer(self.server_ip)
cups.setPort(self.port)
conn = cups.Connection()
printers = conn.getPrinters()
printer_list = printers.keys()
except RuntimeError:
frappe.throw(_("Failed to connect to server"))
except frappe.ValidationError:
frappe.throw(_("Failed to connect to server"))
return printer_list
def start(self):
self._cpt = 0
if not cups_module:
print(
'/!\\ ERROR /!\\: the PrinterTarget has been disabled because python-cups module is not installed'
)
return False
if not self._target_ip:
print('/!\\ ERROR /!\\: the PrinterTarget IP has not been set')
return False
if self._target_port is None:
self._target_port = 631
cups.setServer(self._target_ip)
cups.setPort(self._target_port)
self.__connection = cups.Connection()
try:
printers = self.__connection.getPrinters()
except cups.IPPError as err:
print('CUPS Server Errror: ', err)
return False
if self._printer_name is not None:
try:
params = printers[self._printer_name]
except:
print("Printer '%s' is not connected to CUPS server!" %
self._printer_name)
return False
else:
self._printer_name, params = printers.popitem()
print("\nDevice-URI: %s\nPrinter Name: %s" %
(params["device-uri"], self._printer_name))
return True
def __init__(self, parent=None, try_as_root=True, lock=False, host=None, port=None, encryption=None):
if host != None:
cups.setServer(host)
if port != None:
cups.setPort(port)
if encryption != None:
cups.setEncryption(encryption)
self._use_password = ""
self._parent = parent
self._try_as_root = try_as_root
self._use_user = cups.getUser()
self._server = cups.getServer()
self._port = cups.getPort()
self._encryption = cups.getEncryption()
self._prompt_allowed = True
self._operation_stack = []
self._lock = lock
self._gui_event = threading.Event()
self._connect()
def serve(self):
try:
server = self.env.config.get("cups.server")
port = self.env.config.get("cups.port")
user = self.env.config.get("cups.user")
password = self.env.config.get("cups.password")
encryption_policy = getattr(
cups, "HTTP_ENCRYPT_%s" % self.env.config.get(
"cups.encryption-policy", default="IF_REQUESTED").upper())
if server is not None:
cups.setServer(server)
if port is not None:
cups.setPort(int(port))
if user is not None:
cups.setUser(user)
if encryption_policy is not None:
cups.setEncryption(encryption_policy)
if password is not None:
def pw_callback(prompt):
return password
cups.setPasswordCB(pw_callback)
self.client = cups.Connection()
sched = PluginRegistry.getInstance(
"SchedulerService").getScheduler()
sched.add_interval_job(self.__gc,
minutes=60,
tag='_internal',
jobstore="ram")
sched.add_interval_job(self.__update_printer_list,
minutes=30,
tag='_internal',
jobstore="ram")
except RuntimeError as e:
self.log.error(str(e))
import cups
cups.setServer("121.248.53.183")
cups.setPort(631)
# conn = cups.Connection()
# print cups.getServer(),cups.getPort()
# conn.printFile('xerox','123.pdf','test',{})
# printers = conn.getPrinters ()
# for printer in printers:
# print printer, printers[printer]["device-uri"]
conn = cups.Connection()
printers = conn.getPrinters()
printer_name = printers.keys()[0]
print printer_name
conn.printFile(printer_name, "1234.pdf", "Photo Booth", {"page-ranges": "3-4", "sides": "two-sided-long-edges"})
# conn.printFile(printer_name, BPicture, "Photo Booth",{"copies": "2"})
printersStatus.labels(
printer=key,
model=value['printer-make-and-model'],
status=value['printer-state-reasons'][0]).set(0)
else:
printersStatus.labels(printer=key,
model=value['printer-make-and-model'],
status='happy').set(1)
if __name__ == '__main__':
# Start up the server to expose the metrics.
start_http_server(args.listen_port)
cups.setServer(args.cups_host)
cups.setPort(args.cups_port)
cups.setUser(args.cups_user)
while True:
try:
conn = cups.Connection()
printers = getPrinterData(conn)
getJobData(conn)
getPrinterStatus(printers)
cupsUp.set(1)
except Exception as e:
cupsUp.set(0)
print(e)
time.sleep(5)
