func main() {
db, err := mgo.Dial(os.Getenv("MONGO_URL"))
if err != nil {
log.Error("Failed to connect to MongoDB", "error", err)
os.Exit(1)
return
}
defer db.Close()
ops, errs := gtm.Tail(db, >m.Options{
OpLogCollectionName: &OplogCollection,
Filter: func(op *gtm.Op) bool {
return op.Namespace == "dg.lists"
},
})
for {
select {
case err = <-errs:
log.Error("Error from oplog tail", "error", err)
case <-ops:
log.Info("Change event")
Reload()
}
}
}
func main() {
log.Debug("Starting up...")
dev, err := i2c.New(0x77, 1)
if err != nil {
log.Error("Error: %v", err)
}
bme, err := bme280.NewI2CDriver(dev)
if err != nil {
log.Error("Error: %v", err)
}
for {
weather, err := bme.Readenv()
density := atmosphere.AirDensity(atmosphere.TemperatureC(weather.Temp),
atmosphere.Pressure(weather.Press*100),
atmosphere.RelativeHumidity(weather.Hum))
if err != nil {
log.Error("Error: %v", err)
} else {
log.Debug(fmt.Sprintf("Temperature (degC) %2.2f, pressure (mbar) %4.2f, humidity %2.2f, Density %2.3f kg/m3, CorrFact %1.4f",
weather.Temp, weather.Press, weather.Hum, float64(density), float64(density*0.8)))
}
<-time.After(5 * time.Second)
}
}
func uploadPodcast(r *http.Request) (uploadFile UploadFile, err error) {
file, header, err := r.FormFile("file")
if err != nil {
return uploadFile, err
}
defer file.Close()
target := filepath.Join(common.Storage, header.Filename)
out, err := os.Create(target)
if err != nil {
return uploadFile, err
}
defer out.Close()
// write the content from POST to the file
_, err = io.Copy(out, file)
if err != nil {
return uploadFile, err
}
filetype, invalid := isLegalFileFormat(target)
if invalid {
log.Error("invalid filetype detected", "file", target, "filetype", filetype)
deleteError := os.Remove(target)
if deleteError != nil {
log.Error("could not delete invalid file", "file", target, "filetype", filetype)
}
}
fileInfo, _ := out.Stat()
uploadFile.Name = header.Filename
uploadFile.Size = fileInfo.Size()
return uploadFile, nil
}
func main() {
app := cli.NewApp()
app.Name = "Cabify Store"
app.Usage = "Cabify"
app.Version = "0.0.1"
app.Flags = []cli.Flag{
cli.StringFlag{"config, c", "config.yaml", "config file to use", "APP_CONFIG"},
}
app.Commands = []cli.Command{
{
Name: "server",
Usage: "Run Cabify Store http server",
Action: func(c *cli.Context) {
cfg, err := getConfig(c)
if err != nil {
log.Error(err.Error())
return
}
svc := service.CabifyService{}
if err = svc.Run(cfg); err != nil {
log.Error(err.Error())
}
log.Info("Cabify Store server started")
},
},
}
app.Run(os.Args)
}
func moveMP3toStorageDirectory(watchdir, storage string) {
files, err := ioutil.ReadDir(watchdir)
if err != nil {
log.Error("scan error", "error", err)
return
}
for _, file := range files {
if !file.IsDir() {
if strings.HasSuffix(file.Name(), "mp3") {
source := filepath.Join(watchdir, file.Name())
target := filepath.Join(storage, file.Name())
// first copy file
log.Info("about to copy file", "source", source, "target", target)
err := copyFileContents(source, target)
if err != nil {
log.Error("copy error", "error", err)
return
}
// then delete original file
err = os.Remove(source)
if err != nil {
log.Error("error deleting source file", "error", err)
}
}
log.Debug("only process mp3 files")
}
}
}
// Write out the new files
func Write() error {
var err error
var result Item
// Create the temp files
wl, err := os.Create("/etc/dansguardian/exceptionlist_db")
if err != nil {
log.Error("Failed to create temporary whitelist", "error", err)
return err
}
defer wl.Close()
gl, err := os.Create("/etc/dansguardian/greylist_db")
if err != nil {
log.Error("Failed to create temporary greylist", "error", err)
return err
}
defer gl.Close()
bl, err := os.Create("/etc/dansguardian/blacklist_db")
if err != nil {
log.Error("Failed to create temporary blacklist", "error", err)
return err
}
defer bl.Close()
// Get the list
session, err := mgo.Dial(os.Getenv("MONGO_URL"))
if err != nil {
log.Error("Failed to connect to MongoDB", "error", err)
return err
}
defer session.Close()
session.SetMode(mgo.Monotonic, true)
i := session.DB("dg").C("lists").Find(nil).Iter()
for i.Next(&result) {
switch result.List {
case "whitelist":
_, err = wl.WriteString(fmt.Sprintf("%s\n", result.Name))
case "greylist":
_, err = gl.WriteString(fmt.Sprintf("%s\n", result.Name))
case "blacklist":
_, err = bl.WriteString(fmt.Sprintf("%s\n", result.Name))
}
}
return err
}
func TestAudioToBracelet(t *testing.T) {
llog.Info("Start test")
audio, err := s.GetAudio("./test.amr")
if err != nil {
llog.Error("Erorr", "err", err)
t.FailNow()
}
length := len(audio)
// Divide file in parts
var parts int
if length%s.BufferSize == 0 {
parts = length / s.BufferSize
} else {
parts = length/s.BufferSize + 1
}
from := Expect{"ARA": Data{"", 1, "666"}, "ASA": Data{"", 1, "666"}, "ARD": Data{"", 1, ""}}
to := Expect{"RAU": Data{"", 1, ""}, "SAE": Data{"", 1, ""}} // "SAU": Data{"", parts, ""},
br := Registration(from, to, t)
br.Lock()
br.Commands["666"] = audio
br.Unlock()
command := fmt.Sprintf("RAU&M%v&%v&%v&%v&%v&%v", br.Clients[0], 666, length, parts, 10, "DF")
br, from, to = SendInstruction(br, from, to, command, "ARD", false, t)
if !(from.Done() && to.Done()) {
t.Fail()
}
br.Logger.Info("End of the test")
server.RemoveBracelet(TestingID)
llog.Info("End test")
}
func SendInstruction(br *s.Bracelet, from, to Expect, command string, header string, check bool, t *testing.T) (*s.Bracelet, Expect, Expect) {
if command != "" {
if _, err := br.Write(command); err != nil {
llog.Error("Err", "error", err)
t.Fatal("Can't write message to bracelet")
}
br.Logger.Info("Execute", "command", command)
to.Check(command, "to bracelet")
}
ch := make(chan struct{}, 200)
for i := 0; i < 200; i++ {
ch <- struct{}{}
}
go Listen(br, from, to, t, ch)
for {
if header == "" {
time.Sleep(time.Second * 5)
break
}
if from[header].Msg == "" {
time.Sleep(time.Second * 5)
continue
}
if !from.CheckStatus(header) && check {
t.Fatal("Wrong code")
}
break
}
Wait()
close(ch)
return br, from, to
}
func main() {
// read environment vars
common.ReadEnvironment()
// initialise mux router
router := mux.NewRouter()
// setup statics
poddy.CreateStaticBox(router)
// setup watchdirectory
if common.Watch != "" {
check, err := os.Stat(common.Watch)
if err != nil || !check.IsDir() {
log.Error("error setting up watchdirectory (point to directory?)")
} else {
poddy.EnableWatchdirectory(common.Watch)
}
}
// http handles
router.HandleFunc("/", poddy.IndexPage)
router.HandleFunc("/add-podcast", poddy.AddPodcast)
router.HandleFunc("/feed", poddy.Feed)
router.PathPrefix("/download").Handler(http.StripPrefix("/download", http.FileServer(http.Dir("storage/"))))
// start server
log.Info("poddy is running/listening", "host", common.Host, "port", common.Port)
err := http.ListenAndServe(fmt.Sprintf("%s:%d", common.Host, common.Port), router)
if err != nil {
log.Crit("daemon could not bind on interface", "host", common.Host, "port", common.Port)
os.Exit(1)
}
}
// GetData retrieves and calculates the metrics to be displayed in the report page.
func getData(data *Info) error {
currentFolder, err := osext.ExecutableFolder()
if err != nil {
log.Error("Could not retrieve current folder. Attempting to use dot(.) instead...", "error", err)
currentFolder = "."
}
dbFilePath := currentFolder + "/values.db"
db, err := sql.Open("sqlite3", dbFilePath)
if err != nil {
log.Crit("Failed to opend database", "error", err, "path", dbFilePath)
return err
}
defer db.Close()
rows, err := db.Query("SELECT timestamp, ping, download, upload FROM bandwidth")
if err != nil {
log.Crit("Could not retrieve data from database", "error", err)
return err
}
defer rows.Close()
min := 10000.0 // Unfortunately, I don't see myself with a 10000Mbit/s connection anytime soon...
max := 0.0
counter := 0
average := 0.0
data.Points = [][]interface{}{{map[string]string{"type": "datetime", "label": "Time"}, "Download", "Upload"}}
for rows.Next() {
var timestamp string
var ping, download, upload float64
rows.Scan(×tamp, &ping, &download, &upload)
if download < min {
min = download
}
if download > max {
max = download
}
average += download
counter++
// Timestamp is presented as YYYY-MM-DD HH:MI:SS.Milli+0000
split := strings.Split(timestamp, " ")
dateOnly := strings.Split(string(split[0]), "-")
timeOnly := strings.Split(string(split[1]), ".")
timeOnly = strings.Split(string(timeOnly[0]), ":")
axis := fmt.Sprintf("Date(%s, %s, %s, %s, %s, %s)", dateOnly[0], dateOnly[1], dateOnly[2], timeOnly[0], timeOnly[1], timeOnly[2])
data.Points = append(data.Points, []interface{}{axis, download, upload})
}
data.MinValue = min
data.MaxValue = max
data.AvgValue = average / float64(counter)
data.LastValue = data.Points[len(data.Points)-1][1].(float64)
return nil
}
// Reload Dansguardian configurations
func Reload() {
err := Write()
if err != nil {
log.Error("Failed to write new files; not reloading Dansguardian", "error", err)
return
}
// Tell dansguardian to reload
cmd := exec.Command("/usr/sbin/dansguardian", "-g")
err = cmd.Run()
if err != nil {
log.Error("Failed to reload dansguardian", "error", err)
}
return
}
func (a *albumJob) startDownloader() {
defer a.downloadSync.Done()
for item := range a.downloadQueue {
buf := a.bufferPool.Get()
log.Debug("Processing album item",
"artist", item.Artist,
"title", item.Title,
"url", item.ItemURL,
)
err := downloadURL(buf, item.DownloadURL)
if err != nil {
log.Error("Unable to download item",
"download_url", item.DownloadURL,
"error", err,
)
return
}
a.zipQueue <- zipFile{
Filename: item.Name(),
Buffer: buf,
}
log.Info("Processed album item",
"download_url", item.DownloadURL,
"filename", item.Name(),
)
}
}
func (p *Peer) handleTCPRequest(conn net.Conn) {
defer conn.Close()
b := make([]byte, 1024)
reader := bufio.NewReader(conn)
_, err := reader.Read(b)
if err != nil {
log.Error("Read error", log.Ctx{"error": err})
return
}
// decode
r, err := decode(b, p.config.EncryptionKey)
if err != nil {
p.logger.Error("Decode error", log.Ctx{"error": err})
return
}
switch r.(type) {
case *joinRequest:
p.store.peerAdd(r.(*joinRequest).Peer)
joinResponse := &joinResponse{
Peer: p.store.toPeer(),
Peers: p.store.toMap(),
}
r, err := encode(joinResponse, p.config.EncryptionKey, p.config.UDPBufferSize)
if err != nil {
p.logger.Error("Encode error", log.Ctx{"error": err})
return
}
_, err = conn.Write(r)
if err != nil {
p.logger.Error("Write error", log.Ctx{"error": err})
}
return
default:
log.Error("Unknown type")
}
}
// This function logs a fatal error and kills the process.
func fatalErr(err error, prefix string) {
if err != nil {
defer db.Close()
msg := fmt.Sprintf("%s: %s", prefix, err.Error())
log.Error(msg)
panic(msg)
}
}
func loadConfig(c *Config) {
err := viper.ReadInConfig() // Find and read the config file
if err != nil { // Handle errors reading the config file
log.Error("Fatal error config file.", "error", err)
} else {
c.Alert = viper.Get("alert")
}
}
func main() {
options := cfg.GetOptions()
log.Info("Server is ready!", "port", options.Port, "token", options.Token)
log.Info(fmt.Sprintf("Listening for post requests on http://localhost:%s/events", options.Port))
log.Info(fmt.Sprintf("SSE streaming avaliable on http://localhost:%s/stream", options.Port))
es := eventsource.New(
eventsource.DefaultSettings(),
func(req *http.Request) [][]byte {
return [][]byte{
[]byte("X-Accel-Buffering: no"),
[]byte("Access-Control-Allow-Origin: *"),
[]byte("Cache-Control: no-cache"),
}
},
)
defer es.Close()
r := mux.NewRouter()
r.Handle("/stream", es)
r.HandleFunc("/event/{event}/{id}", func(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
if token, ok := r.Header["X-Token"]; ok {
if token[0] == options.Token {
event := mux.Vars(r)["event"]
id := mux.Vars(r)["id"]
data, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Error("Cannot read body", "err", err)
}
es.SendEventMessage(string(data), event, id)
log.Info("Message has been sent", "id", id, "event", event)
} else {
log.Warn("The request has wrong token", "token", token[0])
http.Error(w, "The request has wrong token", http.StatusUnauthorized)
}
} else {
log.Warn("The request doesn't contain authentication token")
http.Error(w, "The request doesn't contain authentication token", http.StatusUnauthorized)
}
} else {
log.Warn("Received wrong http request")
http.Error(w, "POST requests only", http.StatusMethodNotAllowed)
}
})
r.Handle("/", http.FileServer(http.Dir("./public")))
http.ListenAndServe(fmt.Sprintf(":%s", options.Port), r)
}
func init() {
cfg, err := ini.Load("./config.ini")
if err != nil {
log.Error("Cannot read ./config.ini;", "err", err)
}
options.Port = cfg.Section("").Key("port").String()
options.Token = cfg.Section("").Key("token").String()
}
func genSessionID() ([]byte, error) {
sessionID := make([]byte, 16)
_, err := io.ReadFull(rand.Reader, sessionID)
if err != nil {
log.Error("Unable to create session because unable to read random bytes", "error", err)
return nil, err
}
return sessionID, err
}
func downloadURL(buf *bytes.Buffer, url string) error {
log.Debug("Downloading item", "download_url", url)
response, err := http.Get(url)
if err != nil {
log.Error("Unable to request album item", "download_url", url)
return err
}
defer response.Body.Close()
io.Copy(buf, response.Body)
return nil
}
func loadUsersCSV() error {
// Open and parse existing users from the uat file
usersFile, err := os.OpenFile("users.csv", os.O_RDWR|os.O_CREATE, 0664)
if err != nil {
log.Error("Failed to open users file", "error", err.Error())
return err
}
defer usersFile.Close()
csvReader := csv.NewReader(usersFile)
rawCSV, err := csvReader.ReadAll()
if err != nil {
log.Error("Failed to read CSV file", "error", err.Error())
return err
}
for _, row := range rawCSV {
u := User{row[0], row[1]}
Users[u.Username] = u
}
return nil
}
func TestMain(m *testing.M) {
Log := llog.New()
h, _ := llog.FileHandler("./test.txt", llog.LogfmtFormat())
Log.SetHandler(h)
server = s.NewServer(Log, ":81234")
n, err := nats.Connect("nats://localhost:4222")
if err != nil {
llog.Error("Can't connect to NATS", "error", err)
return
}
nc, _ := nats.NewEncodedConn(n, nats.JSON_ENCODER)
l, err := net.Listen("tcp", ":8080")
if err != nil {
nc.Close()
llog.Error("Can't listen on provided port", "error", err)
return
}
server.BC = l
server.NC = nc
server.Loc, _ = time.LoadLocation(s.BraceletLocation)
log.Println("Connections established")
os.Exit(m.Run())
}
func (tr *CabifyResource) OrderSum(c *gin.Context) {
var data api.Order
var arr []string
var summ float32
summ = 0
log.Info("Started")
err := c.Bind(&data)
if err != nil {
c.JSON(400, api.NewError("problem decoding body"))
return
}
log.Info("Items parcing, data is: " + data.Items)
arr = strings.Split(data.Items, ",")
if arr == nil {
log.Error("Empty order list, please fill it")
}
var VOUCHER_cnt = strings.Count(data.Items, api.VOUCHER)
var TSHIRT_cnt = strings.Count(data.Items, api.TSHIRT)
var MUG_cnt = strings.Count(data.Items, api.MUG)
log.Info("The number of " + api.VOUCHER + " occurence = " + strconv.Itoa(int(VOUCHER_cnt)))
log.Info("The number of " + api.TSHIRT + " occurence = " + strconv.Itoa(int(TSHIRT_cnt)))
log.Info("The number of " + api.MUG + " occurence = " + strconv.Itoa(int(MUG_cnt)))
if TSHIRT_cnt >= 3 {
summ = summ + float32(TSHIRT_cnt*api.CFO_DISCONT_TSHIRT_PRICE)
} else if (TSHIRT_cnt < 3) && (TSHIRT_cnt > 0) {
summ = summ + api.TSHIRT_PRICE
}
if VOUCHER_cnt > 0 {
summ = summ + api.VOUCHER_PRICE
if math.Mod(float64(MUG_cnt), 2) == 0 {
summ = summ + float32(int(VOUCHER_cnt/2))*api.VOUCHER_PRICE
}
}
summ = summ + float32(MUG_cnt)*api.MUG_PRICE
c.JSON(200, gin.H{
"Order Summ": fmt.Sprintf("%.2f", summ),
"Status": "Success",
})
}
func (a *albumJob) startZipper() {
defer a.zipSync.Done()
zipBuffer := zip.NewWriter(a.zipWriter)
defer zipBuffer.Close()
for file := range a.zipQueue {
filename := file.Filename
log.Debug("Creating new item in archive",
"filename", filename,
)
f, err := zipBuffer.Create(filename)
if err != nil {
log.Error("Unable to create new item in archive",
"filename", filename,
)
return
}
log.Debug("Copying buffer into zip file",
"filename", filename,
)
_, err = io.Copy(f, file.Buffer)
if err != nil {
log.Error("Unable to copy buffer into zip file",
"filename", filename,
)
return
}
a.bufferPool.Put(file.Buffer)
zipBuffer.Flush()
}
log.Debug("Archive completed")
}
// FileList returns slice of UploadedFiles
func FileList() []UploadFile {
items := []UploadFile{}
log.Debug("opening dir", "dirname", common.Storage)
list, err := ioutil.ReadDir(common.Storage)
if err != nil {
log.Error("storage error", "error", err)
}
for _, file := range list {
newFile := UploadFile{}
if file.Mode().IsRegular() {
newFile.Name = file.Name()
newFile.Size = file.Size()
}
items = append(items, newFile)
}
return items
}
func initSocket() *socketio.Server {
server, err := socketio.NewServer(nil)
if err != nil {
fmt.Println("Failed to start socket server")
return nil
}
server.On("connection", func(so socketio.Socket) {
fmt.Printf("New socket.io connection: %s", so.Id())
so.Join(socketRoom)
so.On("disconnection", func() {
// no op
})
})
server.On("error", func(so socketio.Socket, err error) {
log.Error("Error on socket.io server", "error", err.Error())
})
return server
}
func isLegalFileFormat(target string) (filetype string, invalid bool) {
file, err := os.Open(target)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
// why 512 bytes ? see http://golang.org/pkg/net/http/#DetectContentType
buff := make([]byte, 512)
_, err = file.Read(buff)
if err != nil {
log.Error("unable to determine filetype", "file", target, "message", err)
return "unknown", true
}
filetype = http.DetectContentType(buff)
if filetype != "application/octet-stream" {
return filetype, true
}
return filetype, false
}
// Speed generates the report page.
func Speed(w http.ResponseWriter, r *http.Request) {
currentFolder, err := osext.ExecutableFolder()
if err != nil {
log.Error("Could not retrieve current folder. Attempting to use dot(.) instead...", "error", err)
currentFolder = "."
}
files := []string{currentFolder + "/html/templates/speed.html"}
t, err := template.ParseFiles(files...)
if err != nil {
log.Crit("Failed to load template", "error", err, "templates", files)
return
}
data := Info{}
getData(&data)
err = t.Execute(w, data)
if err != nil {
log.Crit("Failed to apply data to template", "error", err, "data", data)
return
}
}
// Logs a non-fatal error.
func checkErr(err error, prefix string) {
if err != nil {
msg := fmt.Sprintf("%s: %s", prefix, err.Error())
log.Error(msg)
}
}