Mercurial > gemma

comparison pkg/geoserver/boot.go @ 5490:5f47eeea988d logging

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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,