func main() {
var config shuttle.ShuttleConfig
var err error
config.ParseFlags()
if config.PrintVersion {
fmt.Println(shuttle.VERSION)
os.Exit(0)
}
if !config.UseStdin() {
shuttle.ErrLogger.Fatalln("No stdin detected.")
}
if config.LogToSyslog {
shuttle.Logger, err = syslog.NewLogger(syslog.LOG_INFO|syslog.LOG_SYSLOG, 0)
if err != nil {
log.Fatalf("Unable to setup syslog logger: %s\n", err)
}
shuttle.ErrLogger, err = syslog.NewLogger(syslog.LOG_ERR|syslog.LOG_SYSLOG, 0)
if err != nil {
log.Fatalf("Unable to setup syslog error logger: %s\n", err)
}
}
reader, deliverableBatches, programStats, batchWaiter, outletWaiter := MakeBasicBits(config)
// Blocks until closed
reader.Read(os.Stdin)
// Shutdown everything else.
Shutdown(reader.Outbox, programStats.Input, deliverableBatches, batchWaiter, outletWaiter)
}
func NewSysLogger() *SysLogger {
sl := &SysLogger{
loggers: make(map[LogLevel]*log.Logger),
}
sl.loggers[DEBUG], _ = syslog.NewLogger(syslog.LOG_DEBUG, log.LstdFlags)
sl.loggers[INFO], _ = syslog.NewLogger(syslog.LOG_INFO, log.LstdFlags)
sl.loggers[WARN], _ = syslog.NewLogger(syslog.LOG_WARNING, log.LstdFlags)
sl.loggers[ERROR], _ = syslog.NewLogger(syslog.LOG_ERR, log.LstdFlags)
return sl
}
func NewJobManager() (*JobManager, error) {
var err error
jm := JobManager{Shell: "/bin/sh"}
Logger, err = syslog.NewLogger(syslog.LOG_NOTICE|syslog.LOG_CRON, 0)
if err != nil {
return nil, &JobberError{What: "Couldn't make Syslog logger.", Cause: err}
}
ErrLogger, err = syslog.NewLogger(syslog.LOG_ERR|syslog.LOG_CRON, 0)
if err != nil {
return nil, &JobberError{What: "Couldn't make Syslog logger.", Cause: err}
}
jm.loadedJobs = false
jm.jobRunner = NewJobRunnerThread()
return &jm, nil
}
func getSysLogger() *log.Logger {
logger, err := syslog.NewLogger(syslog.LOG_INFO, log.LstdFlags)
if err != nil {
log.Fatal(err)
}
return logger
}
func (c *sysLogger) LoadConfig(config map[string]interface{}) error {
if level, ok := config["level"]; ok {
c.level = level.(int)
} else {
c.level = LevelDebug
}
if sysLevel, ok := config["sysLevel"]; ok {
c.sysLevel = LocalLevel[sysLevel.(int)]
} else {
c.sysLevel = syslog.LOG_LOCAL6
}
var Flags int
if flags, ok := config["flags"]; ok {
Flags = flags.(int)
} else {
Flags = 9
}
var err error
c.logger, err = syslog.NewLogger(syslog.LOG_NOTICE|syslog.Priority(c.sysLevel), Flags)
if err != nil {
return errors.New("syslog newLogger error")
}
return nil
}
func main() {
mode = flag.String("m", "tcp", "portguard work mode: tcp or udp")
debug = flag.Bool("d", false, "debug mode, print log to stderr")
portCacheDuration = flag.Int64("duration", 120, "port cache duration")
flag.Usage = usage
flag.Parse()
if *debug {
mainLogger = log.New(io.Writer(os.Stderr), "", log.Ldate|log.Lmicroseconds)
} else {
var err error
if mainLogger, err = syslog.NewLogger(syslog.LOG_ERR|syslog.LOG_LOCAL7, log.Ldate|log.Lmicroseconds); err != nil {
logMain(true, "open syslog failed:%s", err.Error())
}
}
args := flag.Args()
if len(args) > 0 {
readConfigFile(args[0])
}
configGuard()
configEcho()
if *mode == "tcp" {
tcpGuard()
} else if *mode == "udp" {
udpGuard()
} else {
fmt.Fprintf(os.Stderr, "don't support mode: %s\n", *mode)
}
}
// Send debug message to syslog facility
func ToSyslog() {
syslogger, err := syslog.NewLogger(syslog.LOG_ERR|syslog.LOG_USER, 0)
if err == nil {
debugLogger = syslogger
prefixFormat = formatMap[false]
}
}
// Factory method for application
// Makes it possible to do integration testing.
func HttpServer() *echo.Echo {
// Initialize global syslog logger
if l, err := syslog.NewLogger(syslog.LOG_NOTICE|syslog.LOG_LOCAL0, 0); err != nil {
panic("gdo: failed to initialize syslog logger: " + err.Error())
} else {
logger = l
}
// Setup middleware
e := echo.New()
e.Use(middleware.RequestID) // Put that first so loggers can log request id
e.Use(em.Logger) // Log to console
e.Use(middleware.HttpLogger(logger)) // Log to syslog
e.Use(gdm.DOClientInitializer(*dumpFlag)) // Initialize DigitalOcean API client
// Setup routes
SetupDropletsRoutes(e.Group("/droplets"))
SetupDropletActionsRoutes(e.Group("/droplets/:id/actions"))
SetupImagesRoutes(e.Group("/images"))
SetupImageActionsRoutes(e.Group("/images/:id/actions"))
SetupActionsRoutes(e.Group("/actions"))
SetupKeysRoutes(e.Group("/keys"))
SetupRegionsRoutes(e.Group("/regions"))
SetupSizesRoutes(e.Group("/sizes"))
// We're done
return e
}
func newSyslogger(p syslog.Priority) *log.Logger {
logger, err := syslog.NewLogger(p, 0)
if err != nil {
panic(err)
}
return logger
}
func mustLog(p syslog.Priority) *log.Logger {
p = p | syslog.LOG_DAEMON
l, err := syslog.NewLogger(p, logFlags)
if err != nil {
panic("Failed to set up logger: " + err.Error())
}
return l
}
func initLogger() *log.Logger {
if configuration.LogToSyslog {
l, _ := syslog.NewLogger(syslog.LOG_INFO, log.LstdFlags)
return l
} else {
return log.New(os.Stdout, "surl ", log.LstdFlags)
}
}
func init() {
var err error
log.SetFlags(LOG_FLAGS)
Logger, err = syslog.NewLogger(LOG_PRIORITY, LOG_FLAGS)
if err != nil {
log.Fatal(err)
}
}
func initLogger(slog bool) {
if slog {
l, err := syslog.NewLogger(syslog.LOG_INFO, 0)
if err != nil {
corelog.Fatalf("Can't initialize logger: %v", err)
}
log = l
}
}
func NewRealLogger() *RealLogger {
logger := log.New(os.Stdout, "", log.LstdFlags)
infoSysLogger, _ := syslog.NewLogger(syslog.LOG_INFO, log.LstdFlags)
return &RealLogger{
logger: logger,
infoSysLogger: infoSysLogger,
}
}
func main() {
var (
configFile string
dry bool
)
logger, err := syslog.NewLogger(syslog.LOG_INFO, stdlog.LstdFlags)
if err != nil {
stdlog.Fatal(err)
}
log.SetLogger(logger)
flag.StringVar(&configFile, "config", "/etc/tsuru/tsuru.conf", "tsuru config file")
flag.BoolVar(&dry, "dry", false, "dry-run: does not start the agent (for testing purposes)")
flag.Parse()
err = config.ReadConfigFile(configFile)
if err != nil {
fatal(err)
}
connString, err := config.GetString("database:url")
if err != nil {
fatal(err)
}
dbName, err := config.GetString("database:name")
if err != nil {
fatal(err)
}
db.Session, err = db.Open(connString, dbName)
if err != nil {
fatal(err)
}
defer db.Session.Close()
fmt.Printf("Connected to MongoDB server at %s.\n", connString)
fmt.Printf("Using the database %q.\n\n", dbName)
if !dry {
provisioner, err := config.GetString("provisioner")
if err != nil {
fmt.Printf("Warning: %q didn't declare a provisioner, using default provisioner.\n", configFile)
provisioner = "juju"
}
app.Provisioner, err = provision.Get(provisioner)
if err != nil {
fatal(err)
}
fmt.Printf("Using %q provisioner.\n\n", provisioner)
qServer, err := config.GetString("queue-server")
if err != nil {
fatal(err)
}
fmt.Printf("Connected to queue server at %s.\n", qServer)
go handleMessages()
ticker := time.Tick(time.Minute)
fmt.Println("tsuru collector agent started...")
jujuCollect(ticker)
}
}
func Logger(prefix string) *log.Logger {
logger, err := syslog.NewLogger(syslog.LOG_NOTICE, log.Lshortfile)
if err != nil {
panic(err)
}
logger.SetPrefix("[" + prefix + "] ")
return logger
}
func init() {
var err error
logger, err = syslog.NewLogger(syslog.LOG_LOCAL0, 0)
if err != nil {
fmt.Printf("create logger failed:%s", err.Error())
os.Exit(1)
}
logger.Println("are you lucky? go!")
rand.Seed(time.Now().Unix())
}
func initLogger() {
if *useSyslog {
var err error
logger, err = syslog.NewLogger(syslog.LOG_NOTICE|syslog.LOG_DAEMON, log.LstdFlags|log.Lmicroseconds)
panicOnError(err)
}
// Set log prefix to process ID to distinguish parent/child
logger.SetPrefix(fmt.Sprintf("[%5d] ", os.Getpid()))
}
// Init sets up the logging functionality
// TODO: Allow priority and type to by set in config
func (sh *SyslogHandler) Init() error {
logger, err := syslog.NewLogger(syslog.LOG_ALERT|syslog.LOG_AUTH, 12)
if err != nil {
return fmt.Errorf("Unable to initialize syslog handler: %s", err)
}
logger.SetFlags(0)
sh.logger = logger
return nil
}
func openSyslog(level Priority, prefix string) *log.Logger {
logger, err := syslog.NewLogger(syslog.Priority(level), log.Lshortfile)
if err != nil {
fmt.Println("Error opening syslog: ", err)
return nil
}
logger.SetPrefix(prefix)
return logger
}
func init() {
var err error
flag.Parse()
l, err = syslog.NewLogger(syslog.LOG_USER|syslog.LOG_WARNING, 0)
if err != nil {
os.Exit(-1)
}
if *verbose {
l.Printf("sending signal\n")
}
}
func newLogger(out *os.File, p syslog.Priority, prefix string) (*log.Logger, error) {
if out == Syslog {
l, err := syslog.NewLogger(p, log.LstdFlags)
if err != nil {
return nil, err
}
l.SetPrefix(prefix + " ")
return l, nil
}
return log.New(out, fmt.Sprintf("[%s]%s ", priorityString[p], prefix), log.LstdFlags), nil
}
func main() {
priority := syslog.LOG_LOCAL3 | syslog.LOG_NOTICE
flags := log.Ldate | log.Lshortfile
logger, err := syslog.NewLogger(priority, flags)
if err != nil {
fmt.Printf("Can't attach to syslog: %s", err)
return
}
logger.Println("This is a test log message.")
}
func main() {
config, err := getConfig()
if err != nil {
errLogger.Fatalf("error=%q\n", err)
}
config.ID = version
if !useStdin() {
errLogger.Fatalln(`error="No stdin detected."`)
}
s := shuttle.NewShuttle(config)
// Setup the loggers before doing anything else
if logToSyslog {
s.Logger, err = syslog.NewLogger(syslog.LOG_INFO|syslog.LOG_SYSLOG, 0)
if err != nil {
errLogger.Fatalf(`error="Unable to setup syslog logger: %s\n"`, err)
}
s.ErrLogger, err = syslog.NewLogger(syslog.LOG_ERR|syslog.LOG_SYSLOG, 0)
if err != nil {
errLogger.Fatalf(`error="Unable to setup syslog error logger: %s\n"`, err)
}
} else {
s.Logger = logger
s.ErrLogger = errLogger
}
s.LoadReader(os.Stdin)
s.Launch()
go LogFmtMetricsEmitter(s.MetricsRegistry, config.StatsSource, config.StatsInterval, s.Logger)
// blocks until the readers all exit
s.WaitForReadersToFinish()
// Shutdown the shuttle.
s.Land()
}
func NewShallowHAProxyLogRecord(out io.Writer, w http.ResponseWriter, r *http.Request) *HAProxyLogRecord {
tlog, err := syslog.NewLogger(syslog.LOG_LOCAL5|syslog.LOG_INFO, 0)
//if cannot connect to syslog just get basic logger to stdout
if err != nil {
tlog = log.New(os.Stdout, "", 0)
}
return &HAProxyLogRecord{
ResponseWriter: w,
Request: r,
sLog: tlog,
}
}
func init() {
flag.BoolVar(&forceUpdate, "f", false, "update noip even if IP hasn't changed")
flag.BoolVar(&addHost, "a", false, "print config with added host to stdout")
flag.Parse()
if addHost {
infoLog = log.New(os.Stdout, "", 0)
errLog = log.New(os.Stdout, "", 0)
} else {
var err error
infoLog, err = syslog.NewLogger(syslog.LOG_INFO, 0)
checkErr(err)
errLog, err = syslog.NewLogger(syslog.LOG_ERR, 0)
checkErr(err)
}
err := readConfig()
if addHost && os.IsNotExist(err) {
return
}
checkErr(err)
}
func main() {
// Create a new syslog container to send to notice/local0
// and include the file shortname
// Setup to log to notice/local0
// Log using file short name
s, err := syslog.NewLogger(syslog.LOG_NOTICE|syslog.LOG_LOCAL0, log.Lshortfile)
if err != nil {
panic(err)
}
// Log "GOTUTORIAL" message
s.Println("GOTUTORIAL")
}
// New creates a new Log and returns pointer to it.
func New(prefix string, sp syslog.Priority, cp syslog.Priority) (*Log, error) {
l := new(Log)
consoleFlags := log.Ldate | log.Ltime | log.Lshortfile
l.conlog1 = log.New(os.Stdout, prefix+": ", consoleFlags)
l.conlog2 = log.New(os.Stderr, prefix+": ", consoleFlags)
l.sp = sp
l.cp = cp
var err error
if l.syslog, err = syslog.NewLogger(syslog.LOG_INFO, log.Lshortfile); err != nil {
return nil, err
}
return l, nil
}
func NewSysLogger(level int) (result *DefaultLogger, err error) {
result = &DefaultLogger{}
priorities := []syslog.Priority{syslog.LOG_CRIT, syslog.LOG_ERR, syslog.LOG_WARNING, syslog.LOG_INFO, syslog.LOG_DEBUG}
loggers := []**log.Logger{&result.CriticalLogger, &result.ErrorLogger, &result.WarningLogger, &result.InfoLogger, &result.DebugLogger}
for index, logger := range loggers {
if level >= index {
*logger, err = syslog.NewLogger(priorities[index], 0)
if err != nil {
return
}
}
}
return
}
// StartLogger initializes the log file.
func StartLogger() {
var err error
if BOOT {
if logFile, err = os.OpenFile(_LOG_FILE, os.O_WRONLY|os.O_TRUNC, 0); err != nil {
log.Print(err)
} else {
Log = log.New(logFile, "", log.Lshortfile)
}
} else {
if Log, err = syslog.NewLogger(syslog.LOG_NOTICE, log.Lshortfile); err != nil {
log.Fatal(err)
}
}
}