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)