// deleteAllGCPPrinters finds all GCP printers associated with this
// connector, deletes them from GCP.
func deleteAllGCPPrinters() {
config, err := lib.ConfigFromFile()
if err != nil {
panic(err)
}
gcpXMPPPingIntervalDefault, err := time.ParseDuration(config.XMPPPingIntervalDefault)
if err != nil {
glog.Fatalf("Failed to parse xmpp ping interval default: %s", err)
}
gcp, err := gcp.NewGoogleCloudPrint(config.GCPBaseURL, config.RobotRefreshToken,
config.UserRefreshToken, config.ProxyName, config.GCPOAuthClientID,
config.GCPOAuthClientSecret, config.GCPOAuthAuthURL, config.GCPOAuthTokenURL,
gcpXMPPPingIntervalDefault, 0, nil)
if err != nil {
glog.Fatal(err)
}
printers, err := gcp.List()
if err != nil {
glog.Fatal(err)
}
ch := make(chan bool)
for gcpID, name := range printers {
go func(gcpID, name string) {
err := gcp.Delete(gcpID)
if err != nil {
fmt.Printf("Failed to delete %s \"%s\": %s\n", gcpID, name, err)
} else {
fmt.Printf("Deleted %s \"%s\" from GCP\n", gcpID, name)
}
ch <- true
}(gcpID, name)
}
for _ = range printers {
<-ch
}
}
func main() {
flag.Parse()
fmt.Println(lib.FullName)
config, err := lib.ConfigFromFile()
if err != nil {
panic(err)
}
if _, err := os.Stat(config.MonitorSocketFilename); err != nil {
if !os.IsNotExist(err) {
panic(err)
}
panic(fmt.Sprintf(
"No connector is running, or the monitoring socket %s is mis-configured",
config.MonitorSocketFilename))
}
timer := time.AfterFunc(*timeoutFlag, func() {
panic(fmt.Sprintf("timeout after %s", timeoutFlag.String()))
})
conn, err := net.DialTimeout("unix", config.MonitorSocketFilename, time.Second)
if err != nil {
panic(fmt.Sprintf(
"No connector is running, or it is not listening to socket %s",
config.MonitorSocketFilename))
}
defer conn.Close()
buf, err := ioutil.ReadAll(conn)
if err != nil {
panic(err)
}
timer.Stop()
fmt.Printf(string(buf))
}
// updateConfigFile opens the config file, adds any missing fields,
// writes the config file back.
func updateConfigFile() {
// Config as parsed by the connector.
config, err := lib.ConfigFromFile()
if err != nil {
panic(err)
}
// Same config in []byte format.
configRaw, err := ioutil.ReadFile(*lib.ConfigFilename)
if err != nil {
panic(err)
}
// Same config in map format so that we can detect missing keys.
var configMap map[string]interface{}
if err = json.Unmarshal(configRaw, &configMap); err != nil {
panic(err)
}
// No changes detected yet.
dirty := false
if _, exists := configMap["gcp_max_concurrent_downloads"]; !exists {
dirty = true
fmt.Println("Added gcp_max_concurrent_downloads")
config.GCPMaxConcurrentDownloads = lib.DefaultConfig.GCPMaxConcurrentDownloads
}
if _, exists := configMap["cups_max_connections"]; !exists {
dirty = true
fmt.Println("Added cups_max_connections")
config.CUPSMaxConnections = lib.DefaultConfig.CUPSMaxConnections
}
if _, exists := configMap["cups_connect_timeout"]; !exists {
dirty = true
fmt.Println("Added cups_connect_timeout")
config.CUPSConnectTimeout = lib.DefaultConfig.CUPSConnectTimeout
}
if _, exists := configMap["cups_job_queue_size"]; !exists {
dirty = true
fmt.Println("Added cups_job_queue_size")
config.CUPSJobQueueSize = lib.DefaultConfig.CUPSJobQueueSize
}
if _, exists := configMap["cups_printer_poll_interval"]; !exists {
dirty = true
fmt.Println("Added cups_printer_poll_interval")
config.CUPSPrinterPollInterval = lib.DefaultConfig.CUPSPrinterPollInterval
}
if _, exists := configMap["cups_printer_attributes"]; !exists {
dirty = true
fmt.Println("Added cups_printer_attributes")
config.CUPSPrinterAttributes = lib.DefaultConfig.CUPSPrinterAttributes
} else {
// Make sure all required attributes are present.
s := make(map[string]struct{}, len(config.CUPSPrinterAttributes))
for _, a := range config.CUPSPrinterAttributes {
s[a] = struct{}{}
}
for _, a := range lib.DefaultConfig.CUPSPrinterAttributes {
if _, exists := s[a]; !exists {
dirty = true
fmt.Printf("Added %s to cups_printer_attributes\n", a)
config.CUPSPrinterAttributes = append(config.CUPSPrinterAttributes, a)
}
}
}
if _, exists := configMap["cups_job_full_username"]; !exists {
dirty = true
fmt.Println("Added cups_job_full_username")
config.CUPSJobFullUsername = lib.DefaultConfig.CUPSJobFullUsername
}
if _, exists := configMap["cups_ignore_raw_printers"]; !exists {
dirty = true
fmt.Println("Added cups_ignore_raw_printers")
config.CUPSIgnoreRawPrinters = lib.DefaultConfig.CUPSIgnoreRawPrinters
}
if _, exists := configMap["copy_printer_info_to_display_name"]; !exists {
dirty = true
fmt.Println("Added copy_printer_info_to_display_name")
config.CopyPrinterInfoToDisplayName = lib.DefaultConfig.CopyPrinterInfoToDisplayName
}
if _, exists := configMap["monitor_socket_filename"]; !exists {
dirty = true
fmt.Println("Added monitor_socket_filename")
config.MonitorSocketFilename = lib.DefaultConfig.MonitorSocketFilename
}
if _, exists := configMap["gcp_base_url"]; !exists {
dirty = true
fmt.Println("Added gcp_base_url")
config.GCPBaseURL = lib.DefaultConfig.GCPBaseURL
}
if _, exists := configMap["xmpp_server"]; !exists {
dirty = true
fmt.Println("Added xmpp_server")
config.XMPPServer = lib.DefaultConfig.XMPPServer
}
if _, exists := configMap["xmpp_port"]; !exists {
dirty = true
fmt.Println("Added xmpp_port")
config.XMPPPort = lib.DefaultConfig.XMPPPort
}
if _, exists := configMap["gcp_xmpp_ping_timeout"]; !exists {
dirty = true
fmt.Println("Added gcp_xmpp_ping_timeout")
config.XMPPPingTimeout = lib.DefaultConfig.XMPPPingTimeout
}
if _, exists := configMap["gcp_xmpp_ping_interval_default"]; !exists {
dirty = true
fmt.Println("Added gcp_xmpp_ping_interval_default")
config.XMPPPingIntervalDefault = lib.DefaultConfig.XMPPPingIntervalDefault
}
if _, exists := configMap["gcp_oauth_client_id"]; !exists {
dirty = true
fmt.Println("Added gcp_oauth_client_id")
config.GCPOAuthClientID = lib.DefaultConfig.GCPOAuthClientID
}
if _, exists := configMap["gcp_oauth_client_secret"]; !exists {
dirty = true
fmt.Println("Added gcp_oauth_client_secret")
config.GCPOAuthClientSecret = lib.DefaultConfig.GCPOAuthClientSecret
}
if _, exists := configMap["gcp_oauth_auth_url"]; !exists {
dirty = true
fmt.Println("Added gcp_oauth_auth_url")
config.GCPOAuthAuthURL = lib.DefaultConfig.GCPOAuthAuthURL
}
if _, exists := configMap["gcp_oauth_token_url"]; !exists {
dirty = true
fmt.Println("Added gcp_oauth_token_url")
config.GCPOAuthTokenURL = lib.DefaultConfig.GCPOAuthTokenURL
}
if _, exists := configMap["snmp_enable"]; !exists {
dirty = true
fmt.Println("Added snmp_enable")
config.SNMPEnable = lib.DefaultConfig.SNMPEnable
}
if _, exists := configMap["snmp_community"]; !exists {
dirty = true
fmt.Println("Added snmp_community")
config.SNMPCommunity = lib.DefaultConfig.SNMPCommunity
}
if _, exists := configMap["snmp_max_connections"]; !exists {
dirty = true
fmt.Println("Added snmp_max_connections")
config.SNMPMaxConnections = lib.DefaultConfig.SNMPMaxConnections
}
if _, exists := configMap["local_printing_enable"]; !exists {
dirty = true
fmt.Println("Added local_printing_enable")
config.LocalPrintingEnable = lib.DefaultConfig.LocalPrintingEnable
}
if _, exists := configMap["cloud_printing_enable"]; !exists {
dirty = true
fmt.Println("Added cloud_printing_enable")
config.CloudPrintingEnable = lib.DefaultConfig.CloudPrintingEnable
}
if dirty {
config.ToFile()
fmt.Printf("Wrote %s\n", *lib.ConfigFilename)
} else {
fmt.Println("Nothing to update")
}
}
func main() {
flag.Parse()
defer glog.Flush()
glog.Error(lib.FullName)
fmt.Println(lib.FullName)
config, err := lib.ConfigFromFile()
if err != nil {
glog.Fatal(err)
}
if _, err := os.Stat(config.MonitorSocketFilename); !os.IsNotExist(err) {
if err != nil {
glog.Fatal(err)
}
glog.Fatalf(
"A connector is already running, or the monitoring socket %s wasn't cleaned up properly",
config.MonitorSocketFilename)
}
cupsConnectTimeout, err := time.ParseDuration(config.CUPSConnectTimeout)
if err != nil {
glog.Fatalf("Failed to parse cups connect timeout: %s", err)
}
gcpXMPPPingTimeout, err := time.ParseDuration(config.XMPPPingTimeout)
if err != nil {
glog.Fatalf("Failed to parse xmpp ping timeout: %s", err)
}
gcpXMPPPingIntervalDefault, err := time.ParseDuration(config.XMPPPingIntervalDefault)
if err != nil {
glog.Fatalf("Failed to parse xmpp ping interval default: %s", err)
}
gcp, err := gcp.NewGoogleCloudPrint(config.GCPBaseURL, config.RobotRefreshToken, config.UserRefreshToken,
config.ProxyName, config.GCPOAuthClientID, config.GCPOAuthClientSecret,
config.GCPOAuthAuthURL, config.GCPOAuthTokenURL, gcpXMPPPingIntervalDefault)
if err != nil {
glog.Fatal(err)
}
xmpp, err := xmpp.NewXMPP(config.XMPPJID, config.ProxyName, config.XMPPServer, config.XMPPPort, gcpXMPPPingTimeout, gcpXMPPPingIntervalDefault, gcp.GetRobotAccessToken)
if err != nil {
glog.Fatal(err)
}
defer xmpp.Quit()
cups, err := cups.NewCUPS(config.CopyPrinterInfoToDisplayName, config.CUPSPrinterAttributes,
config.CUPSMaxConnections, cupsConnectTimeout, gcp.Translate)
if err != nil {
glog.Fatal(err)
}
defer cups.Quit()
var snmpManager *snmp.SNMPManager
if config.SNMPEnable {
glog.Info("SNMP enabled")
snmpManager, err = snmp.NewSNMPManager(config.SNMPCommunity, config.SNMPMaxConnections)
if err != nil {
glog.Fatal(err)
}
defer snmpManager.Quit()
}
pm, err := manager.NewPrinterManager(cups, gcp, xmpp, snmpManager, config.CUPSPrinterPollInterval,
config.GCPMaxConcurrentDownloads, config.CUPSJobQueueSize, config.CUPSJobFullUsername,
config.CUPSIgnoreRawPrinters, config.ShareScope)
if err != nil {
glog.Fatal(err)
}
defer pm.Quit()
m, err := monitor.NewMonitor(cups, gcp, pm, config.MonitorSocketFilename)
if err != nil {
glog.Fatal(err)
}
defer m.Quit()
glog.Errorf("Ready to rock as proxy '%s'\n", config.ProxyName)
fmt.Printf("Ready to rock as proxy '%s'\n", config.ProxyName)
waitIndefinitely()
glog.Error("Shutting down")
fmt.Println("")
fmt.Println("Shutting down")
}
func main() {
flag.Parse()
defer glog.Flush()
glog.Error(lib.FullName)
fmt.Println(lib.FullName)
var config *lib.Config
if lib.ConfigFileExists() {
var err error
config, err = lib.ConfigFromFile()
if err != nil {
glog.Fatal(err)
}
} else {
config = &lib.DefaultConfig
glog.Info("No config file was found, so using defaults")
}
if !config.CloudPrintingEnable && !config.LocalPrintingEnable {
glog.Fatal("Cannot run connector with both local_printing_enable and cloud_printing_enable set to false")
}
if _, err := os.Stat(config.MonitorSocketFilename); !os.IsNotExist(err) {
if err != nil {
glog.Fatal(err)
}
glog.Fatalf(
"A connector is already running, or the monitoring socket %s wasn't cleaned up properly",
config.MonitorSocketFilename)
}
cupsConnectTimeout, err := time.ParseDuration(config.CUPSConnectTimeout)
if err != nil {
glog.Fatalf("Failed to parse cups connect timeout: %s", err)
}
gcpXMPPPingTimeout, err := time.ParseDuration(config.XMPPPingTimeout)
if err != nil {
glog.Fatalf("Failed to parse xmpp ping timeout: %s", err)
}
gcpXMPPPingIntervalDefault, err := time.ParseDuration(config.XMPPPingIntervalDefault)
if err != nil {
glog.Fatalf("Failed to parse xmpp ping interval default: %s", err)
}
jobs := make(chan *lib.Job, 10)
xmppNotifications := make(chan xmpp.PrinterNotification, 5)
var g *gcp.GoogleCloudPrint
var x *xmpp.XMPP
if config.CloudPrintingEnable {
g, err = gcp.NewGoogleCloudPrint(config.GCPBaseURL, config.RobotRefreshToken,
config.UserRefreshToken, config.ProxyName, config.GCPOAuthClientID,
config.GCPOAuthClientSecret, config.GCPOAuthAuthURL, config.GCPOAuthTokenURL,
gcpXMPPPingIntervalDefault, config.GCPMaxConcurrentDownloads, jobs)
if err != nil {
glog.Fatal(err)
}
x, err = xmpp.NewXMPP(config.XMPPJID, config.ProxyName, config.XMPPServer, config.XMPPPort,
gcpXMPPPingTimeout, gcpXMPPPingIntervalDefault, g.GetRobotAccessToken, xmppNotifications)
if err != nil {
glog.Fatal(err)
}
defer x.Quit()
}
c, err := cups.NewCUPS(config.CopyPrinterInfoToDisplayName, config.CUPSPrinterAttributes,
config.CUPSMaxConnections, cupsConnectTimeout)
if err != nil {
glog.Fatal(err)
}
defer c.Quit()
var s *snmp.SNMPManager
if config.SNMPEnable {
glog.Info("SNMP enabled")
s, err = snmp.NewSNMPManager(config.SNMPCommunity, config.SNMPMaxConnections)
if err != nil {
glog.Fatal(err)
}
defer s.Quit()
}
var priv *privet.Privet
if config.LocalPrintingEnable {
if g == nil {
priv, err = privet.NewPrivet(jobs, config.GCPBaseURL, nil)
} else {
priv, err = privet.NewPrivet(jobs, config.GCPBaseURL, g.ProximityToken)
}
if err != nil {
glog.Fatal(err)
}
defer priv.Quit()
}
pm, err := manager.NewPrinterManager(c, g, priv, s, config.CUPSPrinterPollInterval,
config.CUPSJobQueueSize, config.CUPSJobFullUsername, config.CUPSIgnoreRawPrinters,
config.ShareScope, jobs, xmppNotifications)
if err != nil {
glog.Fatal(err)
}
defer pm.Quit()
m, err := monitor.NewMonitor(c, g, pm, config.MonitorSocketFilename)
if err != nil {
glog.Fatal(err)
}
defer m.Quit()
if config.CloudPrintingEnable {
if config.LocalPrintingEnable {
glog.Errorf("Ready to rock as proxy '%s' and in local mode", config.ProxyName)
fmt.Printf("Ready to rock as proxy '%s' and in local mode\n", config.ProxyName)
} else {
glog.Errorf("Ready to rock as proxy '%s'", config.ProxyName)
fmt.Printf("Ready to rock as proxy '%s'\n", config.ProxyName)
}
} else {
glog.Error("Ready to rock in local-only mode")
fmt.Println("Ready to rock in local-only mode")
}
waitIndefinitely()
glog.Error("Shutting down")
fmt.Println("")
fmt.Println("Shutting down")
}
