github.com/Ryan-Johnson-1315/socketlogger@v0.0.2/logger.go (about)

     1  package socketlogger
     2  
     3  import (
     4  	"io"
     5  	"log"
     6  	"os"
     7  	"path/filepath"
     8  	"runtime"
     9  )
    10  
    11  type LoggerServer interface {
    12  	SetLogFile(string, string) error
    13  	SetTimeFlags(flags int) error
    14  	Server
    15  }
    16  
    17  type loggerserver struct {
    18  	flush chan bool
    19  }
    20  
    21  func (l *loggerserver) SetLogFile(dir, name string) error {
    22  	var err error
    23  	var logFile *os.File
    24  	if !fileDirExists(dir, "") {
    25  		err = os.MkdirAll(dir, os.ModePerm)
    26  		if err != nil {
    27  			return err
    28  		}
    29  	}
    30  	logFile, err = os.OpenFile(filepath.Join(dir, name), os.O_CREATE|os.O_APPEND|os.O_RDWR, 0o666)
    31  	if err == nil {
    32  		log.SetOutput(io.MultiWriter(os.Stdout, logFile))
    33  	}
    34  
    35  	return err
    36  }
    37  
    38  func (l *loggerserver) SetTimeFlags(flags int) error {
    39  	log.SetFlags(flags)
    40  	return nil
    41  }
    42  
    43  func (l *loggerserver) getMessageType() SocketMessage {
    44  	return &LogMessage{}
    45  }
    46  
    47  func (l *loggerserver) setFlushChannel(flush chan bool) {
    48  	l.flush = flush
    49  }
    50  
    51  func (l *loggerserver) write(msgs chan SocketMessage) {
    52  	for msg := range msgs {
    53  		log.Printf("%s\n", msg)
    54  	}
    55  	l.flush <- true
    56  }
    57  
    58  type UdpLoggerServer struct {
    59  	loggerserver
    60  	udpserver
    61  }
    62  
    63  func NewUdpLoggerServer() LoggerServer {
    64  	u := &UdpLoggerServer{}
    65  	u.init(u)
    66  	return u
    67  }
    68  
    69  type TcpLoggerServer struct {
    70  	tcpserver
    71  	loggerserver
    72  }
    73  
    74  func NewTcpLoggerServer() LoggerServer {
    75  	t := &TcpLoggerServer{}
    76  	t.init(t)
    77  	return t
    78  }
    79  
    80  type LoggerClient interface {
    81  	Log(format string, args ...interface{})
    82  	Wrn(format string, args ...interface{})
    83  	Dbg(format string, args ...interface{})
    84  	Err(format string, args ...interface{})
    85  	Success(format string, args ...interface{})
    86  	Client
    87  }
    88  
    89  type loggerclient struct {
    90  	msgsToSend chan SocketMessage
    91  }
    92  
    93  func (l *loggerclient) setMsgChannel(msgsToSend chan SocketMessage) {
    94  	l.msgsToSend = msgsToSend
    95  }
    96  
    97  func (l *loggerclient) Log(format string, args ...interface{}) {
    98  	_, file, line, ok := runtime.Caller(1)
    99  	l.msgsToSend <- newLogMessageCaller(MessageLevelLog, file, line, ok, format, args...)
   100  }
   101  
   102  func (l *loggerclient) Wrn(format string, args ...interface{}) {
   103  	_, file, line, ok := runtime.Caller(1)
   104  	l.msgsToSend <- newLogMessageCaller(MessageLevelWrn, file, line, ok, format, args...)
   105  }
   106  
   107  func (l *loggerclient) Dbg(format string, args ...interface{}) {
   108  	_, file, line, ok := runtime.Caller(1)
   109  	l.msgsToSend <- newLogMessageCaller(MessageLevelDbg, file, line, ok, format, args...)
   110  }
   111  
   112  func (l *loggerclient) Err(format string, args ...interface{}) {
   113  	_, file, line, ok := runtime.Caller(1)
   114  	l.msgsToSend <- newLogMessageCaller(MessageLevelErr, file, line, ok, format, args...)
   115  }
   116  
   117  func (l *loggerclient) Success(format string, args ...interface{}) {
   118  	_, file, line, ok := runtime.Caller(1)
   119  	l.msgsToSend <- newLogMessageCaller(MessageLevelSuccess, file, line, ok, format, args...)
   120  }
   121  
   122  type UdpLoggerClient struct {
   123  	loggerclient
   124  	udpClient
   125  }
   126  
   127  func NewUdpLoggerClient() LoggerClient {
   128  	u := &UdpLoggerClient{}
   129  	u.init(u)
   130  	return u
   131  }
   132  
   133  type TcpLoggerClient struct {
   134  	loggerclient
   135  	tcpClient
   136  }
   137  
   138  func NewTcpLoggerClient() LoggerClient {
   139  	t := &TcpLoggerClient{}
   140  	t.init(t)
   141  	return t
   142  }