summary refs log tree commit diff
path: root/server.go
blob: b1faa8b09117619e0f08b5d1d43573f895e01606 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"strings"

	"net/http"

	TLE "git.darknebu.la/Satellite/TLE"
	"github.com/gorilla/mux"
)

var (
	categories []string
	port       int
)

func main() {
	initFlags()
	r := mux.NewRouter()

	r.HandleFunc("/", indexHandler)
	r.HandleFunc("/dumpall", dumpallHandler)
	r.HandleFunc("/{station}/{name}", getHandler)

	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), r))
}

func initFlags() {
	flag.IntVar(&port, "p", 8080, "the port the server should listen on")
	flag.Parse()
}

func indexHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "%s", "<h1>Hello World</h1>")
}

// dumpallHandler dumps all categories
func dumpallHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("[ ] Dumping all TLEs")

	// read the name of the categories from the categories.txt file and write
	// the result to the categories slice
	content, err := ioutil.ReadFile("categories.txt")
	if err != nil {
		log.Printf("%s", "could not read categories.txt file!")
	}
	lines := strings.Split(string(content), "\n")

	for _, line := range lines {
		categories = append(categories, line)
	}

	// download all the categories to the data/<category name> directory
	for _, category := range categories {
		downloadCategory(category)
	}

	log.Println("[+] Done dumping all TLEs")
}

// downloadCategory downloads the given category from celestrack
func downloadCategory(categoryName string) {

	// define where to download the TLEs from
	base := "https://celestrak.com/NORAD/elements/"
	downloadURL := fmt.Sprintf("%s%s.txt", base, categoryName)

	// define the HTTP GET request and make it
	resp, err := http.Get(downloadURL)
	if err != nil {
		log.Printf("Could not download %s", categoryName)
	}
	defer resp.Body.Close()

	// read the respose from the GET request
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Printf("Could not read the category %s", categoryName)
	}

	// write the response to the corresponding file
	filename := fmt.Sprintf("data/%s.txt", categoryName)
	f, err := os.Create(filename) // creating the file
	if err != nil {
		fmt.Printf("Could not create file data/%s.txt", categoryName)
	}
	_, err = f.WriteString(string(body)) // writing the TLE to the file
	if err != nil {
		fmt.Printf("Could not write to file data/%s.txt", categoryName)
	}
}

// get Handler returns the specified TLE
func getHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)

	// read the TLEs from the categories file
	//content, err := ioutil.ReadFile("categories.txt")
	//if err != nil {
	//	log.Println("Could note read categories.txt")
	//}

	// handle the response according to the query parameter "format"
	// if ?format=json is given, return
	if r.URL.Query().Get("format") == "json" {
		w.Header().Set("Content-Type", "application/json")

		RawTLE := `ISS (ZARYA)             
1 25544U 98067A   19229.39083552  .00000228  00000-0  11917-4 0  9993
2 25544  51.6447  57.6210 0007373 294.0868 138.8050 15.50381554184754`

		JSONTLE, err := TLE.NewTLE(RawTLE)
		if err != nil {
			fmt.Println(err)
		}

		// convert the TLE to json
		b, err := json.MarshalIndent(JSONTLE, "", " ")
		if err != nil {
			fmt.Println("error: ", err)
		}
		fmt.Fprintf(w, string(b))
		//fmt.Fprintf(w, "{\"response\": \"Getting the TLE for %s/%s as json\"}", vars["station"], vars["name"])
	} else {
		fmt.Fprintf(w, "Getting the TLE for %s/%s raw", vars["station"], vars["name"])
	}

}