func SetupLogging(loggingLevel, logFile string) {
level := log.DEBUG
switch loggingLevel {
case "info":
level = log.INFO
case "warn":
level = log.WARNING
case "error":
level = log.ERROR
}
log.Global = make(map[string]*log.Filter)
Global = log.Global
if logFile == "stdout" || logFile == "" {
flw := log.NewConsoleLogWriter()
log.AddFilter("stdout", level, flw)
} else if logFile == "stderr" || logFile == "" {
flw := log.NewConsoleLogWriter()
log.AddFilter("stderr", level, flw)
} else {
logFileDir := filepath.Dir(logFile)
os.MkdirAll(logFileDir, 0744)
flw := log.NewFileLogWriter(logFile, false)
log.AddFilter("file", level, flw)
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(true)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(true)
}
Global.Info("Redirectoring logging to %s %s", logFile, level)
}
func setupLogging(loggingLevel, logFile string) {
level := log.DEBUG
switch loggingLevel {
case "info":
level = log.INFO
case "warn":
level = log.WARNING
case "error":
level = log.ERROR
}
for _, filter := range log.Global {
filter.Level = level
}
if logFile == "stdout" {
log.AddFilter("stdout", level, log.NewConsoleLogWriter())
} else {
logDir := filepath.Dir(logFile)
if err := os.MkdirAll(logDir, 0744); err != nil {
panic(err)
}
writer := log.NewFileLogWriter(logFile, false)
log.AddFilter("file", level, writer)
writer.SetFormat("[%D %t] [%L] (%S) %M")
writer.SetRotate(true)
writer.SetRotateSize(0)
writer.SetRotateLines(0)
writer.SetRotateDaily(true)
}
}
func main() {
l4g.AddFilter("stdout", l4g.WARNING, l4g.NewConsoleLogWriter())
if len(os.Args) < 2 {
printUsage()
} else {
discover := goupnp.DiscoverIGD()
if os.Args[1] == "s" {
igd := <-discover
status := <-igd.GetConnectionStatus()
fmt.Printf("%+v\n", status)
} else if os.Args[1] == "l" {
igd := <-discover
for portMapping := range igd.ListRedirections() {
fmt.Println(portMapping)
}
} else if os.Args[1] == "a" {
igd := <-discover
port, _ := strconv.Atoi(os.Args[2])
proto := goupnp.ParseProtocol(os.Args[3])
myMapping := <-igd.AddLocalPortRedirection(uint16(port), proto)
fmt.Printf("%+v\n", myMapping)
} else {
printUsage()
}
}
time.Sleep(1 * time.Second)
}
func init() {
// Tests outside of config_test.go also require this configuration to be
// loaded; Config tests should reset it by making this call
loadTestConfig("test-walker.yaml")
// For tests it's useful to see more than the default INFO
log4go.AddFilter("stdout", log4go.DEBUG, log4go.NewConsoleLogWriter())
}
func initLogger() {
logger = make(log4go.Logger)
logger.AddFilter("stdout", log4go.INFO, log4go.NewConsoleLogWriter())
if logFileName := configCommon("log", INFO); logFileName != "" {
logger.AddFilter("file", log4go.INFO, log4go.NewFileLogWriter(logFileName, false).SetFormat("[%D %T][%L]%M - %S"))
}
logger.Info("log module initialized")
}
func main() {
log4go.AddFilter("file", log4go.FINEST, log4go.NewConsoleLogWriter())
defer func() {
py.NewLock()
py.Finalize()
}()
t = &qmlfrontend{windows: make(map[*backend.Window]*frontendWindow)}
go t.qmlBatchLoop()
qml.Run(t.loop)
}
/*
Init - initialize log lib
RETURNS:
*Logger, nil - if succeed
nil, error - if fail
*/
func (l *Logger) Init() (*Logger, error) {
// check, and create dir if nonexist
if err := logDirCreate(l.logDir); err != nil {
return nil, err
}
// default level: INFO
level := log4go.INFO
if l.enableDebug {
level = log4go.DEBUG
}
// set logger format
logFormat := func(enableDebug bool) string {
if enableDebug {
return log4go.FORMAT_DEFAULT
}
return FORMAT_WITHOUT_SRC
}(l.enableDebug)
// create logger
logger := make(log4go.Logger)
// create writer for stdout
if l.enableStdout {
logger.AddFilter("stdout", level, log4go.NewConsoleLogWriter())
}
// create file writer for all log
fileName := filenameGen(l.progName, l.logDir, false)
logWriter := log4go.NewFileLogWriter(fileName, l.enableRotate)
if l.enableRotate {
logWriter.SetRotateSize(l.rotateSize)
logWriter.SetRotateDaily(true)
}
logWriter.SetFormat(logFormat)
logger.AddFilter("log", level, logWriter)
if l.enableWf {
fileNameWf := filenameGen(l.progName, l.logDir, true)
logWriterWf := log4go.NewFileLogWriter(fileNameWf, l.enableRotate)
if l.enableRotate {
logWriterWf.SetRotateSize(l.rotateSize)
logWriterWf.SetRotateDaily(true)
}
logWriterWf.SetFormat(logFormat)
logger.AddFilter("log_wf", log4go.WARNING, logWriterWf)
}
// set Logger
l.Logger = logger
return l, nil
}
func main() {
log4go.AddFilter("file", log4go.FINEST, log4go.NewConsoleLogWriter())
defer func() {
py.NewLock()
py.Finalize()
}()
var t tbfe
t.dorender = make(chan bool, render_chan_len)
t.layout = make(map[*backend.View]layout)
t.loop()
}
// init sets the default log4go configuration and attempts to read a log4go.xml
// file if available
func init() {
log4go.AddFilter("stdout", log4go.INFO, log4go.NewConsoleLogWriter())
loadLog4goConfig()
sig := make(chan os.Signal)
signal.Notify(sig, syscall.SIGHUP)
go func() {
for {
<-sig
loadLog4goConfig()
}
}()
}
func main() {
log4go.AddFilter("file", log4go.FINEST, log4go.NewConsoleLogWriter())
defer func() {
py.NewLock()
py.Finalize()
}()
var t tbfe
t.layout = make(map[*backend.View]layout)
t.views = make(map[*backend.View]*frontendView)
t.loop()
}
func main() {
// Need to lock the OS thread as OSX GUI requires GUI stuff to run in the main thread
runtime.LockOSThread()
log4go.AddFilter("file", log4go.FINEST, log4go.NewConsoleLogWriter())
defer func() {
py.NewLock()
py.Finalize()
}()
t = &qmlfrontend{windows: make(map[*backend.Window]*frontendWindow)}
go t.qmlBatchLoop()
qml.Run(t.loop)
}
func setupLogging(loggingLevel, logFile string) {
level := log.DEBUG
switch loggingLevel {
case "fine":
level = log.FINE
case "debug":
level = log.DEBUG
case "info":
level = log.INFO
case "warn":
level = log.WARNING
case "error":
level = log.ERROR
default:
log.Error("Unknown log level %s. Defaulting to DEBUG", loggingLevel)
}
log.Global = make(map[string]*log.Filter)
facility, ok := GetSysLogFacility(logFile)
if ok {
flw, err := NewSysLogWriter(facility)
if err != nil {
fmt.Fprintf(os.Stderr, "NewSysLogWriter: %s\n", err.Error())
return
}
log.AddFilter("syslog", level, flw)
} else if logFile == "stdout" {
flw := log.NewConsoleLogWriter()
log.AddFilter("stdout", level, flw)
} else {
logFileDir := filepath.Dir(logFile)
os.MkdirAll(logFileDir, 0744)
flw := log.NewFileLogWriter(logFile, false)
if flw == nil {
os.Exit(1)
}
log.AddFilter("file", level, flw)
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(true)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(true)
}
log.Info("Redirectoring logging to %s", logFile)
}
/*
* Init - initialize log lib
*
* PARAMS:
* - progName: program name. Name of log file will be progName.log
* - levelStr: "DEBUG", "TRACE", "INFO", "WARNING", "ERROR", "CRITICAL"
* - logDir: directory for log. It will be created if noexist
* - hasStdOut: whether to have stdout output
* - when:
* "M", minute
* "H", hour
* "D", day
* "MIDNIGHT", roll over at midnight
* - backupCount: If backupCount is > 0, when rollover is done, no more than
* backupCount files are kept - the oldest ones are deleted.
*
* RETURNS:
* nil, if succeed
* error, if fail
*/
func Init(progName string, levelStr string, logDir string,
hasStdOut bool, when string, backupCount int) error {
if initialized {
return errors.New("Initialized Already")
}
/* check when */
/*if !log4go.WhenIsValid(when) {
return fmt.Errorf("invalid value of when: %s", when)
}*/
/* check, and create dir if nonexist */
if err := logDirCreate(logDir); err != nil {
log4go.Error("Init(), in logDirCreate(%s)", logDir)
return err
}
/* convert level from string to log4go level */
level := stringToLevel(levelStr)
/* create logger */
Logger = make(log4go.Logger)
/* create writer for stdout */
if hasStdOut {
Logger.AddFilter("stdout", level, log4go.NewConsoleLogWriter())
}
/* create file writer for all log */
fileName := filenameGen(progName, logDir, false)
logWriter := log4go.NewTimeFileLogWriter(fileName, when, backupCount)
if logWriter == nil {
return fmt.Errorf("error in log4go.NewTimeFileLogWriter(%s)", fileName)
}
logWriter.SetFormat(log4go.LogFormat)
Logger.AddFilter("log", level, logWriter)
/* create file writer for warning and fatal log */
fileNameWf := filenameGen(progName, logDir, true)
logWriter = log4go.NewTimeFileLogWriter(fileNameWf, when, backupCount)
if logWriter == nil {
return fmt.Errorf("error in log4go.NewTimeFileLogWriter(%s)", fileNameWf)
}
logWriter.SetFormat(log4go.LogFormat)
Logger.AddFilter("log_wf", log4go.WARNING, logWriter)
initialized = true
return nil
}
func main() {
log := make(log4go.Logger)
log.AddFilter("stdout", log4go.DEBUG, log4go.NewConsoleLogWriter())
http.HandleFunc("/", helloThere)
http.HandleFunc("/all", all)
http.HandleFunc("/pointer", PointerExample)
var port string
if port = os.Getenv(PortVar); port == "" {
port = "8080"
}
log.Debug("Listening at port %v\n", port)
if err := http.ListenAndServe(":"+port, nil); err != nil {
panic(err)
}
}
func LogTo(target string, verbosity string) {
var writer log.LogWriter = nil
switch target {
case "stdout":
writer = log.NewConsoleLogWriter()
case "none":
// no logging
default:
writer = log.NewFileLogWriter(target, true)
}
if writer != nil {
setupVerbosity(writer, verbosity)
}
}
func LogTo(target string) {
var writer log.LogWriter = nil
switch target {
case "stdout":
writer = log.NewConsoleLogWriter()
case "none":
// no logging
default:
writer = log.NewFileLogWriter(target, true)
}
if writer != nil {
root.AddFilter("log", log.TRACE, writer)
}
}
func init() {
flag.StringVar(&dhtRouters, "routers", "1.a.magnets.im:6881,router.utorrent.com:6881",
"Comma separated IP:Port address of the DHT routeirs used to bootstrap the DHT network.")
flag.IntVar(&maxNodes, "maxNodes", 500,
"Maximum number of nodes to store in the routing table, in memory. This is the primary configuration for how noisy or aggressive this node should be. When the node starts, it will try to reach maxNodes/2 as quick as possible, to form a healthy routing table.")
flag.DurationVar(&cleanupPeriod, "cleanupPeriod", 15*time.Minute,
"How often to ping nodes in the network to see if they are reachable.")
flag.DurationVar(&savePeriod, "savePeriod", 5*time.Minute,
"How often to save the routing table to disk.")
flag.Int64Var(&rateLimit, "rateLimit", 100,
"Maximum packets per second to be processed. Beyond this limit they are silently dropped. Set to -1 to disable rate limiting.")
// TODO: Control the verbosity via flag.
// Setting during init has two purposes:
// - Gives the calling program the ability to override this filter inside their main().
// - Provides a sane default that isn't excessively verbose.
l4g.AddFilter("stdout", l4g.WARNING, l4g.NewConsoleLogWriter())
}
func init() {
// TODO: Run my own router.
flag.StringVar(&dhtRouter, "dhtRouter", "router.utorrent.com:6881",
"IP:Port address of the DHT router used to bootstrap the DHT network.")
flag.IntVar(&maxNodes, "maxNodes", 1000,
"Maximum number of nodes to store in the routing table, in memory.")
flag.DurationVar(&cleanupPeriod, "cleanupPeriod", 15*time.Minute,
"How often to ping nodes in the network to see if they are reachable.")
flag.DurationVar(&savePeriod, "savePeriod", 5*time.Minute,
"How often to save the routing table to disk.")
flag.Int64Var(&rateLimit, "rateLimit", 100,
"Maximum packets per second to be processed. Beyond this limit they are silently dropped. Set to -1 to disable rate limiting.")
// TODO: Control the verbosity via flag.
// Setting during init has two purposes:
// - Gives the calling program the ability to override this filter inside their main().
// - Provides a sane default that isn't excessively verbose.
l4g.AddFilter("stdout", l4g.WARNING, l4g.NewConsoleLogWriter())
}
// Creates a new FirmataClient object and connects to the Arduino board
// over specified serial port. This function blocks till a connection is
// succesfullt established and pin mappings are retrieved.
func NewClient(dev string, baud int) (client *FirmataClient, err error) {
var conn io.ReadWriteCloser
c := &serial.Config{Name: dev, Baud: baud}
conn, err = serial.OpenPort(c)
if err != nil {
client.Log.Critical(err)
return
}
logger := make(log4go.Logger)
logger.AddFilter("stdout", log4go.INFO, log4go.NewConsoleLogWriter())
client = &FirmataClient{
serialDev: dev,
baud: baud,
conn: &conn,
Log: &logger,
}
go client.replyReader()
conn.Write([]byte{byte(SystemReset)})
t := time.NewTicker(time.Second)
for !(client.ready && client.analogMappingDone && client.capabilityDone) {
select {
case <-t.C:
//no-op
case <-time.After(time.Second * 15):
client.Log.Critical("No response in 30 seconds. Resetting arduino")
conn.Write([]byte{byte(SystemReset)})
case <-time.After(time.Second * 30):
client.Log.Critical("Unable to initialize connection")
conn.Close()
client = nil
}
}
client.Log.Info("Client ready to use")
return
}
func configureLog(s *model.LogSettings) {
l4g.Close()
if s.EnableConsole {
level := l4g.DEBUG
if s.ConsoleLevel == "INFO" {
level = l4g.INFO
} else if s.ConsoleLevel == "WARN" {
level = l4g.WARNING
} else if s.ConsoleLevel == "ERROR" {
level = l4g.ERROR
}
l4g.AddFilter("stdout", level, l4g.NewConsoleLogWriter())
}
if s.EnableFile {
var fileFormat = s.FileFormat
if fileFormat == "" {
fileFormat = "[%D %T] [%L] %M"
}
level := l4g.DEBUG
if s.FileLevel == "INFO" {
level = l4g.INFO
} else if s.FileLevel == "WARN" {
level = l4g.WARNING
} else if s.FileLevel == "ERROR" {
level = l4g.ERROR
}
flw := l4g.NewFileLogWriter(GetLogFileLocation(s.FileLocation), false)
flw.SetFormat(fileFormat)
flw.SetRotate(true)
flw.SetRotateLines(LOG_ROTATE_SIZE)
l4g.AddFilter("file", level, flw)
}
}
func setup_logger() {
filename := "/var/log/ranger/ranger.log"
// Create a default logger that is logging messages of FINE or higher to filename, no rotation
// log.AddFilter("file", l4g.FINE, l4g.NewFileLogWriter(filename, false))
// =OR= Can also specify manually via the following: (these are the defaults, this is equivalent to above)
flw := l4g.NewFileLogWriter(filename, false)
if flw == nil {
fmt.Printf("No permission to write to %s, going to switch to stdout only\n", filename)
} else {
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(false)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(true)
l4g.AddFilter("file", l4g.DEBUG, flw)
l4g.AddFilter("stdout", l4g.ERROR, l4g.NewConsoleLogWriter())
}
}
func main() {
flag.Parse()
// Change to l4g.DEBUG to see *lots* of debugging information.
l4g.AddFilter("stdout", l4g.WARNING, l4g.NewConsoleLogWriter())
if len(flag.Args()) != 1 {
fmt.Fprintf(os.Stderr, "Usage: %v <infohash>\n\n", os.Args[0])
fmt.Fprintf(os.Stderr, "Example infohash: d1c5676ae7ac98e8b19f63565905105e3c4c37a2\n")
flag.PrintDefaults()
os.Exit(1)
}
ih, err := dht.DecodeInfoHash(flag.Args()[0])
if err != nil {
l4g.Critical("DecodeInfoHash error: %v\n", err)
os.Exit(1)
}
// This is a hint to the DHT of the minimum number of peers it will try to
// find for the given node. This is not a reliable limit. In the future this
// might be moved to "PeersRequest()", so the controlling client can have
// different targets at different moments or for different infohashes.
targetNumPeers := 5
d, err := dht.NewDHTNode(dhtPortUDP, targetNumPeers, false)
if err != nil {
l4g.Critical("NewDHTNode error: %v", err)
os.Exit(1)
}
// For debugging.
go http.ListenAndServe(fmt.Sprintf(":%d", httpPortTCP), nil)
go d.DoDHT()
go drainresults(d)
for {
// Give the DHT some time to "warm-up" its routing table.
time.Sleep(5 * time.Second)
d.PeersRequest(string(ih), false)
}
}
/*
* InitWithLogSvr - initialize log lib with remote log server
*
* PARAMS:
* - progName: program name.
* - levelStr: "DEBUG", "TRACE", "INFO", "WARNING", "ERROR", "CRITICAL"
* - loggerName: logger name
* - network: using "udp" or "unixgram"
* - svrAddr: remote unix sock address for all logger
* - svrAddrWf: remote unix sock address for warn/fatal logger
* If svrAddrWf is empty string, no warn/fatal logger will be created.
* - hasStdOut: whether to have stdout output
*
* RETURNS:
* nil, if succeed
* error, if fail
*/
func InitWithLogSvr(progName string, levelStr string, loggerName string,
network string, svrAddr string, svrAddrWf string,
hasStdOut bool) error {
if initialized {
return errors.New("Initialized Already")
}
/* convert level from string to log4go level */
level := stringToLevel(levelStr)
/* create logger */
Logger = make(log4go.Logger)
/* create writer for stdout */
if hasStdOut {
Logger.AddFilter("stdout", level, log4go.NewConsoleLogWriter())
}
/* create file writer for all log */
name := fmt.Sprintf("%s_%s", progName, loggerName)
logWriter := log4go.NewPacketWriter(name, network, svrAddr, log4go.LogFormat)
if logWriter == nil {
return fmt.Errorf("error in log4go.NewPacketWriter(%s)", name)
}
Logger.AddFilter("log", level, logWriter)
if len(svrAddrWf) > 0 {
/* create file writer for warning and fatal log */
logWriterWf := log4go.NewPacketWriter(name+".wf", network, svrAddrWf, log4go.LogFormat)
if logWriterWf == nil {
return fmt.Errorf("error in log4go.NewPacketWriter(%s, %s)",
name, svrAddr)
}
Logger.AddFilter("log_wf", log4go.WARNING, logWriterWf)
}
initialized = true
return nil
}
func LogTo(target string, level_name string) {
var writer log.LogWriter = nil
switch target {
case "stdout":
writer = log.NewConsoleLogWriter()
case "none":
// no logging
default:
writer = log.NewFileLogWriter(target, true)
}
if writer != nil {
var level = log.DEBUG
switch level_name {
case "FINEST":
level = log.FINEST
case "FINE":
level = log.FINE
case "DEBUG":
level = log.DEBUG
case "TRACE":
level = log.TRACE
case "INFO":
level = log.INFO
case "WARNING":
level = log.WARNING
case "ERROR":
level = log.ERROR
case "CRITICAL":
level = log.CRITICAL
default:
level = log.DEBUG
}
root.AddFilter("log", level, writer)
}
}
func configureLog(s LogSettings) {
l4g.Close()
if s.ConsoleEnable {
level := l4g.DEBUG
if s.ConsoleLevel == "INFO" {
level = l4g.INFO
} else if s.ConsoleLevel == "ERROR" {
level = l4g.ERROR
}
l4g.AddFilter("stdout", level, l4g.NewConsoleLogWriter())
}
if s.FileEnable {
if s.FileFormat == "" {
s.FileFormat = "[%D %T] [%L] %M"
}
if s.FileLocation == "" {
s.FileLocation = FindDir("logs") + "mattermost.log"
}
level := l4g.DEBUG
if s.FileLevel == "INFO" {
level = l4g.INFO
} else if s.FileLevel == "ERROR" {
level = l4g.ERROR
}
flw := l4g.NewFileLogWriter(s.FileLocation, false)
flw.SetFormat(s.FileFormat)
flw.SetRotate(true)
flw.SetRotateLines(100000)
l4g.AddFilter("file", level, flw)
}
}
func setupLogging(loggingLevel, logFile string) {
level := log.DEBUG
switch loggingLevel {
case "TRACE":
level = log.TRACE
case "DEBUG":
level = log.DEBUG
case "INFO":
level = log.INFO
case "WARN":
level = log.WARNING
case "ERROR":
level = log.ERROR
}
log.Global = make(map[string]*log.Filter)
if logFile == "stdout" {
flw := log.NewConsoleLogWriter()
log.AddFilter("stdout", level, flw)
} else {
logFileDir := filepath.Dir(logFile)
os.MkdirAll(logFileDir, 0744)
flw := log.NewFileLogWriter(logFile, false)
log.AddFilter("file", level, flw)
flw.SetFormat("[%D %T] [%L] (%S) %M")
flw.SetRotate(true)
flw.SetRotateSize(0)
flw.SetRotateLines(0)
flw.SetRotateDaily(true)
}
log.Info("Redirectoring logging to %s", logFile)
}
func NewLogger(config *LogConfig) Logger {
lvl := log4go.DEBUG
switch config.Level {
case "finest":
lvl = log4go.FINEST
case "fine":
lvl = log4go.FINE
case "trace":
lvl = log4go.TRACE
case "info":
lvl = log4go.INFO
case "warning":
lvl = log4go.WARNING
case "error":
lvl = log4go.ERROR
case "critical":
lvl = log4go.CRITICAL
}
log := make(log4go.Logger)
log.AddFilter("stdout", lvl, log4go.NewConsoleLogWriter())
if config.File != "" {
file := log4go.NewFileLogWriter(config.File, config.Rotate)
if config.Format != "" {
file.SetFormat(config.Format)
}
log.AddFilter("file", lvl, file)
}
return &log
}
func main() {
log := l4g.NewDefaultLogger(l4g.DEBUG)
//输出到控制台,级别为DEBUG
log.AddFilter("stdout", l4g.DEBUG, l4g.NewConsoleLogWriter())
//logs文件夹需要运行前创建，否则异常
//输出到文件,级别为DEBUG,文件名为test.log,每次追加该原文件
log.AddFilter("log", l4g.DEBUG, l4g.NewFileLogWriter("logs/test.log", false))
//使用加载配置文件,类似与java的log4j.propertites
//l4g.LoadConfiguration("log4go.xml")
//l4g.Info("xxx")
//log.Error("yyy")
log.Debug("the time is now :%s -- %s", "213", "sad")
//程序退出太快是来不及写log的
time.Sleep(1000 * time.Millisecond)
//log.Write2Exit()
//注:如果不是一直运行的程序,请加上这句话,否则主线程结束后,也不会输出和log到日志文件
defer log.Close()
}
func main() {
py.InitializeEx(false)
defer py.Finalize()
e := backend.GetEditor()
log4go.AddFilter("stdout", log4go.DEBUG, log4go.NewConsoleLogWriter())
if sc, err := textmate.LoadTheme("../../3rdparty/bundles/TextMate-Themes/GlitterBomb.tmTheme"); err != nil {
log4go.Error(err)
} else {
scheme = sc
log4go.Debug("scheme: %v", scheme)
}
backend.OnNewWindow.Add(new_window)
backend.OnNew.Add(new_view)
backend.OnModified.Add(view_modified)
go e.Init()
qt5.Main(func() {
w := e.NewWindow()
w.OpenFile("main.go", 0)
w.OpenFile("../../backend/editor.go", 0)
qt5.Run()
})
}
func init() {
// TODO: should really log to stderr and not stdout
log4go.Global.AddFilter("stdout", log4go.FINEST, log4go.NewConsoleLogWriter())
}