Mercurial > gemma
comparison pkg/geoserver/boot.go @ 5490:5f47eeea988d logging
Use own logging package.
author | Sascha L. Teichmann <sascha.teichmann@intevation.de> |
---|---|
date | Mon, 20 Sep 2021 17:45:39 +0200 |
parents | 345515bc4548 |
children | 6270951dda28 |
comparison
equal
deleted
inserted
replaced
5488:a726a92ea5c9 | 5490:5f47eeea988d |
---|---|
18 "bytes" | 18 "bytes" |
19 "encoding/json" | 19 "encoding/json" |
20 "encoding/xml" | 20 "encoding/xml" |
21 "fmt" | 21 "fmt" |
22 "io" | 22 "io" |
23 "log" | |
24 "net/http" | 23 "net/http" |
25 "net/url" | 24 "net/url" |
26 "strings" | 25 "strings" |
27 "sync" | 26 "sync" |
28 | 27 |
29 "golang.org/x/net/html/charset" | 28 "golang.org/x/net/html/charset" |
30 | 29 |
31 "gemma.intevation.de/gemma/pkg/config" | 30 "gemma.intevation.de/gemma/pkg/config" |
31 "gemma.intevation.de/gemma/pkg/log" | |
32 "gemma.intevation.de/gemma/pkg/models" | 32 "gemma.intevation.de/gemma/pkg/models" |
33 ) | 33 ) |
34 | 34 |
35 const ( | 35 const ( |
36 workspaceName = "gemma" | 36 workspaceName = "gemma" |
53 func toStream(x interface{}) io.Reader { | 53 func toStream(x interface{}) io.Reader { |
54 var buf bytes.Buffer | 54 var buf bytes.Buffer |
55 | 55 |
56 if err := json.NewEncoder(&buf).Encode(x); err != nil { | 56 if err := json.NewEncoder(&buf).Encode(x); err != nil { |
57 // Should not happen | 57 // Should not happen |
58 log.Printf("warn: bad JSON: %v\n", err) | 58 log.Warnf("bad JSON: %v\n", err) |
59 } | 59 } |
60 return bytes.NewReader(buf.Bytes()) | 60 return bytes.NewReader(buf.Bytes()) |
61 } | 61 } |
62 | 62 |
63 // XXX: Creating SQL views with JSON via GeoServer REST-API fails | 63 // XXX: Creating SQL views with JSON via GeoServer REST-API fails |
64 // Begin code for handling with XML instead | 64 // Begin code for handling with XML instead |
65 func toXMLStream(x interface{}) io.Reader { | 65 func toXMLStream(x interface{}) io.Reader { |
66 buf := bytes.NewBufferString(xml.Header) | 66 buf := bytes.NewBufferString(xml.Header) |
67 if err := xml.NewEncoder(buf).Encode(x); err != nil { | 67 if err := xml.NewEncoder(buf).Encode(x); err != nil { |
68 // Should not happen | 68 // Should not happen |
69 log.Printf("warn: bad XML: %v\n", err) | 69 log.Warnf("bad XML: %v\n", err) |
70 } | 70 } |
71 return bytes.NewReader(buf.Bytes()) | 71 return bytes.NewReader(buf.Bytes()) |
72 } | 72 } |
73 | 73 |
74 func asJSON(req *http.Request) { | 74 func asJSON(req *http.Request) { |
100 if err != nil { | 100 if err != nil { |
101 return err | 101 return err |
102 } | 102 } |
103 | 103 |
104 if resp.StatusCode != http.StatusNotFound { | 104 if resp.StatusCode != http.StatusNotFound { |
105 log.Println("info: workspace " + workspaceName + " already exists.") | 105 log.Infof("workspace " + workspaceName + " already exists.") |
106 return nil | 106 return nil |
107 } | 107 } |
108 | 108 |
109 // Create workspace | 109 // Create workspace |
110 | 110 |
111 log.Println("info: creating workspace " + workspaceName) | 111 log.Infof("creating workspace " + workspaceName) |
112 | 112 |
113 const createJSON = `{"workspace":{"name":"` + workspaceName + `"}}` | 113 const createJSON = `{"workspace":{"name":"` + workspaceName + `"}}` |
114 | 114 |
115 req, err = http.NewRequest( | 115 req, err = http.NewRequest( |
116 http.MethodPost, | 116 http.MethodPost, |
156 if err != nil { | 156 if err != nil { |
157 return err | 157 return err |
158 } | 158 } |
159 | 159 |
160 if resp.StatusCode != http.StatusNotFound { | 160 if resp.StatusCode != http.StatusNotFound { |
161 log.Println("info: datastore " + datastoreName + " already exists.") | 161 log.Infof("datastore " + datastoreName + " already exists.") |
162 return nil | 162 return nil |
163 } | 163 } |
164 | 164 |
165 // Create datastore. | 165 // Create datastore. |
166 log.Println("info: creating datastore " + datastoreName) | 166 log.Infoln("creating datastore " + datastoreName) |
167 | 167 |
168 type entry struct { | 168 type entry struct { |
169 Key interface{} `json:"@key"` | 169 Key interface{} `json:"@key"` |
170 Value interface{} `json:"$"` | 170 Value interface{} `json:"$"` |
171 } | 171 } |
219 } | 219 } |
220 | 220 |
221 func ensureFeatures() error { | 221 func ensureFeatures() error { |
222 tables := models.InternalServices.Filter(models.IntWFS) | 222 tables := models.InternalServices.Filter(models.IntWFS) |
223 if len(tables) == 0 { | 223 if len(tables) == 0 { |
224 log.Println("info: no tables to publish") | 224 log.Infoln("no tables to publish") |
225 return nil | 225 return nil |
226 } | 226 } |
227 | 227 |
228 log.Printf("info: number of tables to publish %d\n", len(tables)) | 228 log.Infof("number of tables to publish %d\n", len(tables)) |
229 | 229 |
230 var ( | 230 var ( |
231 geoURL = config.GeoServerURL() | 231 geoURL = config.GeoServerURL() |
232 user = config.GeoServerUser() | 232 user = config.GeoServerUser() |
233 password = config.GeoServerPassword() | 233 password = config.GeoServerPassword() |
281 | 281 |
282 var already []string | 282 var already []string |
283 | 283 |
284 defer func() { | 284 defer func() { |
285 if len(already) > 0 { | 285 if len(already) > 0 { |
286 log.Printf("info: already having featuretypes: %s\n", | 286 log.Infof("already having featuretypes: %s\n", |
287 strings.Join(already, ", ")) | 287 strings.Join(already, ", ")) |
288 } | 288 } |
289 }() | 289 }() |
290 | 290 |
291 for i := range tables { | 291 for i := range tables { |
295 already = append(already, table) | 295 already = append(already, table) |
296 continue | 296 continue |
297 } | 297 } |
298 | 298 |
299 // Create featuretype. | 299 // Create featuretype. |
300 log.Printf("info: creating featuretype %s.\n", table) | 300 log.Infof("creating featuretype %s.\n", table) |
301 | 301 |
302 var req *http.Request | 302 var req *http.Request |
303 | 303 |
304 ft := map[string]interface{}{ | 304 ft := map[string]interface{}{ |
305 "name": table, | 305 "name": table, |
398 | 398 |
399 func ensureLayerGroups() error { | 399 func ensureLayerGroups() error { |
400 | 400 |
401 groups := models.InternalServices.LayerGroups() | 401 groups := models.InternalServices.LayerGroups() |
402 if len(groups) == 0 { | 402 if len(groups) == 0 { |
403 log.Println("info: no groups layers to publish") | 403 log.Infoln("info: no groups layers to publish") |
404 return nil | 404 return nil |
405 } | 405 } |
406 | 406 |
407 log.Printf("info: number of layer groups to publish %d\n", len(groups)) | 407 log.Infof("number of layer groups to publish %d\n", len(groups)) |
408 | 408 |
409 var ( | 409 var ( |
410 geoURL = config.GeoServerURL() | 410 geoURL = config.GeoServerURL() |
411 user = config.GeoServerUser() | 411 user = config.GeoServerUser() |
412 password = config.GeoServerPassword() | 412 password = config.GeoServerPassword() |
455 | 455 |
456 var already []string | 456 var already []string |
457 | 457 |
458 defer func() { | 458 defer func() { |
459 if len(already) > 0 { | 459 if len(already) > 0 { |
460 log.Printf("info: already having layer groups: %s\n", | 460 log.Infof("already having layer groups: %s\n", |
461 strings.Join(already, ", ")) | 461 strings.Join(already, ", ")) |
462 } | 462 } |
463 }() | 463 }() |
464 | 464 |
465 for i := range groups { | 465 for i := range groups { |
466 if hasLayerGroup(groups[i].Name) { | 466 if hasLayerGroup(groups[i].Name) { |
467 already = append(already, groups[i].Name) | 467 already = append(already, groups[i].Name) |
468 continue | 468 continue |
469 } | 469 } |
470 | 470 |
471 log.Printf("info: creating layer group %s.\n", groups[i].Name) | 471 log.Infof("creating layer group %s.\n", groups[i].Name) |
472 | 472 |
473 type ( | 473 type ( |
474 Layers struct { | 474 Layers struct { |
475 Layer []string `xml:"layer"` | 475 Layer []string `xml:"layer"` |
476 } | 476 } |
527 // Should we delete our workspace first? | 527 // Should we delete our workspace first? |
528 if !config.GeoServerClean() { | 528 if !config.GeoServerClean() { |
529 return nil | 529 return nil |
530 } | 530 } |
531 | 531 |
532 log.Println("info: delete workspace " + workspaceName) | 532 log.Infoln("info: delete workspace " + workspaceName) |
533 var ( | 533 var ( |
534 geoURL = config.GeoServerURL() | 534 geoURL = config.GeoServerURL() |
535 user = config.GeoServerUser() | 535 user = config.GeoServerUser() |
536 password = config.GeoServerPassword() | 536 password = config.GeoServerPassword() |
537 auth = basicAuth(user, password) | 537 auth = basicAuth(user, password) |
624 return err == nil | 624 return err == nil |
625 } | 625 } |
626 | 626 |
627 func updateStyle(entry *models.IntEntry, create bool) error { | 627 func updateStyle(entry *models.IntEntry, create bool) error { |
628 | 628 |
629 log.Printf("info: creating style %s\n", entry.Name) | 629 log.Infof("creating style %s\n", entry.Name) |
630 | 630 |
631 // Try to load the style data. | 631 // Try to load the style data. |
632 binary, err := entry.LoadStyle() | 632 binary, err := entry.LoadStyle() |
633 if err != nil { | 633 if err != nil { |
634 return err | 634 return err |
759 tok, err := decoder.Token() | 759 tok, err := decoder.Token() |
760 switch { | 760 switch { |
761 case tok == nil && err == io.EOF: | 761 case tok == nil && err == io.EOF: |
762 return false | 762 return false |
763 case err != nil: | 763 case err != nil: |
764 log.Printf("warn: invalid XML: %v\n", err) | 764 log.Warnf("invalid XML: %v\n", err) |
765 return false | 765 return false |
766 } | 766 } |
767 if t, ok := tok.(xml.StartElement); ok && | 767 if t, ok := tok.(xml.StartElement); ok && |
768 t.Name.Space == "http://www.opengis.net/se" { | 768 t.Name.Space == "http://www.opengis.net/se" { |
769 return true | 769 return true |
770 } | 770 } |
771 } | 771 } |
772 } | 772 } |
773 | 773 |
774 func ensureStyles() error { | 774 func ensureStyles() error { |
775 log.Println("info: creating styles") | 775 log.Infoln("creating styles") |
776 | 776 |
777 var stls styles | 777 var stls styles |
778 if err := stls.load(); err != nil { | 778 if err := stls.load(); err != nil { |
779 return err | 779 return err |
780 } | 780 } |
786 | 786 |
787 var already []string | 787 var already []string |
788 | 788 |
789 defer func() { | 789 defer func() { |
790 if len(already) > 0 { | 790 if len(already) > 0 { |
791 log.Printf("info: already having styles: %s\n", | 791 log.Infof("already having styles: %s\n", |
792 strings.Join(already, ", ")) | 792 strings.Join(already, ", ")) |
793 } | 793 } |
794 }() | 794 }() |
795 | 795 |
796 for i := range entries { | 796 for i := range entries { |
810 // PrepareGeoServer sets up the GeoServer to work together with the gemma server. | 810 // PrepareGeoServer sets up the GeoServer to work together with the gemma server. |
811 // It sets up a workspace, a datastore and exposes the features and styles. | 811 // It sets up a workspace, a datastore and exposes the features and styles. |
812 func PrepareGeoServer() error { | 812 func PrepareGeoServer() error { |
813 | 813 |
814 if config.DBUser() == "" { | 814 if config.DBUser() == "" { |
815 log.Println("info: Need metamorphic db user to configure GeoServer") | 815 log.Infoln("need metamorphic db user to configure GeoServer") |
816 return nil | 816 return nil |
817 } | 817 } |
818 | 818 |
819 if config.GeoServerURL() == "" { | 819 if config.GeoServerURL() == "" { |
820 log.Println("info: No URL to GeoServer configured") | 820 log.Infoln("no URL to GeoServer configured") |
821 return nil | 821 return nil |
822 } | 822 } |
823 | 823 |
824 for _, ensure := range []func() error{ | 824 for _, ensure := range []func() error{ |
825 deleteWorkspace, | 825 deleteWorkspace, |