// allGCPPrinters calls gcp.List, then calls gcp.Printer, one goroutine per // printer. This is a fast way to fetch all printers with corresponding CDD // info, which the List API does not provide. // // The second return value is a map of GCPID -> queued print job quantity. func allGCPPrinters(gcp *gcp.GoogleCloudPrint) ([]lib.Printer, map[string]uint, error) { ids, err := gcp.List() if err != nil { return nil, nil, err } type response struct { printer *lib.Printer queuedJobsCount uint err error } ch := make(chan response) for id := range ids { go func(id string) { printer, queuedJobsCount, err := gcp.Printer(id) ch <- response{printer, queuedJobsCount, err} }(id) } errs := make([]error, 0) printers := make([]lib.Printer, 0, len(ids)) queuedJobsCount := make(map[string]uint) for _ = range ids { r := <-ch if r.err != nil { errs = append(errs, r.err) continue } printers = append(printers, *r.printer) if r.queuedJobsCount > 0 { queuedJobsCount[r.printer.GCPID] = r.queuedJobsCount } } if len(errs) == 0 { return printers, queuedJobsCount, nil } else if len(errs) == 1 { return nil, nil, errs[0] } else { // Return an error that is somewhat human-readable. b := bytes.NewBufferString(fmt.Sprintf("%d errors: ", len(errs))) for i, err := range errs { if i > 0 { b.WriteString(", ") } b.WriteString(err.Error()) } return nil, nil, errors.New(b.String()) } }
func NewPrinterManager(cups *cups.CUPS, gcp *gcp.GoogleCloudPrint, privet *privet.Privet, snmp *snmp.SNMPManager, printerPollInterval string, cupsQueueSize uint, jobFullUsername, ignoreRawPrinters bool, shareScope string, jobs <-chan *lib.Job, xmppNotifications <-chan xmpp.PrinterNotification) (*PrinterManager, error) { var printers *lib.ConcurrentPrinterMap var queuedJobsCount map[string]uint var err error if gcp != nil { // Get all GCP printers. var gcpPrinters []lib.Printer gcpPrinters, queuedJobsCount, err = gcp.ListPrinters() if err != nil { return nil, err } // Organize the GCP printers into a map. for i := range gcpPrinters { gcpPrinters[i].CUPSJobSemaphore = lib.NewSemaphore(cupsQueueSize) } printers = lib.NewConcurrentPrinterMap(gcpPrinters) } else { printers = lib.NewConcurrentPrinterMap(nil) } // Construct. pm := PrinterManager{ cups: cups, gcp: gcp, privet: privet, snmp: snmp, printers: printers, jobStatsMutex: sync.Mutex{}, jobsDone: 0, jobsError: 0, jobsInFlightMutex: sync.Mutex{}, jobsInFlight: make(map[string]struct{}), cupsQueueSize: cupsQueueSize, jobFullUsername: jobFullUsername, ignoreRawPrinters: ignoreRawPrinters, shareScope: shareScope, quit: make(chan struct{}), } // Sync once before returning, to make sure things are working. // Ignore privet updates this first time because Privet always starts // with zero printers. if err = pm.syncPrinters(true); err != nil { return nil, err } // Initialize Privet printers. if privet != nil { for _, printer := range pm.printers.GetAll() { err := privet.AddPrinter(printer, pm.printers.GetByCUPSName) if err != nil { glog.Warningf("Failed to register %s locally: %s", printer.Name, err) } else { glog.Infof("Registered %s locally", printer.Name) } } } ppi, err := time.ParseDuration(printerPollInterval) if err != nil { return nil, err } pm.syncPrintersPeriodically(ppi) pm.listenNotifications(jobs, xmppNotifications) if gcp != nil { for gcpPrinterID := range queuedJobsCount { p, _ := printers.GetByGCPID(gcpPrinterID) go gcp.HandleJobs(&p, func() { pm.incrementJobsProcessed(false) }) } } return &pm, nil }