Mercurial > gemma

comparison pkg/imports/gm.go @ 5532:7e21a9e6353d aggregate-gm-import-logging

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Cleaned up and simplified code.
author Sascha L. Teichmann <sascha.teichmann@intevation.de>
date Mon, 25 Oct 2021 00:37:39 +0200
parents 84f0c53e6ffe
children 0a2326eda3a5
comparison
equal deleted inserted replaced
5531:84f0c53e6ffe 5532:7e21a9e6353d
361 } 361 }
362 return nil 362 return nil
363 } 363 }
364 364
365 func (gls gmLogs) logging(feedback Feedback) { 365 func (gls gmLogs) logging(feedback Feedback) {
366 gls.logUnknown(feedback) 366 gls.logBool(
367 gls.logAssumedZPG(feedback) 367 (*gmLog).getUnkown,
368 gls.logAssumedCM(feedback) 368 "Cannot find following gauges: ",
369 gls.logBadValues(feedback) 369 feedback.Warn)
370 gls.logMissingValues(feedback) 370
371 gls.logRescaleErrors(feedback) 371 gls.logBool(
372 gls.logIgnoredMeasureCodes(feedback) 372 (*gmLog).getAssumedZPG,
373 gls.logPredictions(feedback) 373 "Reference_code' not specified. Assuming 'ZPG': ",
374 gls.logMeasurements(feedback) 374 feedback.Warn)
375 } 375
376 376 gls.logInt(
377 func (gls gmLogs) logMeasurements(feedback Feedback) { 377 (*gmLog).getAssumedCM,
378 "'Unit' not specified. Assuming 'cm': ",
379 feedback.Warn)
380
381 gls.logInt(
382 (*gmLog).getBadValues,
383 "Ignored measurements with value -99999: ",
384 feedback.Warn)
385
386 gls.logString(
387 (*gmLog).getMissingValues,
388 "Missing mandatory values: ",
389 feedback.Warn)
390
391 gls.logString(
392 (*gmLog).getRescaleErrors,
393 "Cannot convert units: ",
394 feedback.Error)
395
396 gls.logString(
397 (*gmLog).getRescaleErrors,
398 "Ignored measure codes: ",
399 feedback.Warn)
400
401 gls.logInt(
402 (*gmLog).getPredictions,
403 "New predictions: ",
404 feedback.Info)
405
406 gls.logInt(
407 (*gmLog).getMeasurements,
408 "New measurements: ",
409 feedback.Info)
410 }
411
412 func (gl *gmLog) getAssumedZPG() bool { return gl.assumedZPG }
413 func (gl *gmLog) getUnkown() bool { return gl.unknown }
414 func (gl *gmLog) getIgnoredMeasureCodes() []string { return gl.ignoredMeasureCodes }
415 func (gl *gmLog) getRescaleErrors() []string { return gl.rescaleErrors }
416 func (gl *gmLog) getMissingValues() []string { return gl.missingValues }
417 func (gl *gmLog) getAssumedCM() int { return gl.assumedCM }
418 func (gl *gmLog) getBadValues() int { return gl.badValues }
419 func (gl *gmLog) getPredictions() int { return gl.predictions }
420 func (gl *gmLog) getMeasurements() int { return gl.measurements }
421
422 func (gls gmLogs) logBool(
423 access func(*gmLog) bool,
424 header string,
425 log func(string, ...interface{}),
426 ) {
378 var sb strings.Builder 427 var sb strings.Builder
379 for _, gl := range gls { 428 for _, gl := range gls {
380 if gl.measurements > 0 { 429 if access(gl) {
381 if sb.Len() == 0 { 430 if sb.Len() == 0 {
382 sb.WriteString("New measurements: ") 431 sb.WriteString(header)
383 } else { 432 } else {
384 sb.WriteString("; ") 433 sb.WriteString("; ")
385 } 434 }
386 fmt.Fprintf(&sb, "%s (%d)", gl.gid, gl.measurements) 435 sb.WriteString(gl.gid)
387 } 436 }
388 } 437 }
389 if sb.Len() > 0 { 438 if sb.Len() > 0 {
390 feedback.Info(sb.String()) 439 log(sb.String())
391 } 440 }
392 } 441 }
393 442
394 func (gls gmLogs) logPredictions(feedback Feedback) { 443 func (gls gmLogs) logInt(
444 access func(*gmLog) int,
445 header string,
446 log func(string, ...interface{}),
447 ) {
395 var sb strings.Builder 448 var sb strings.Builder
396 for _, gl := range gls { 449 for _, gl := range gls {
397 if gl.predictions > 0 { 450 if v := access(gl); v > 0 {
398 if sb.Len() == 0 { 451 if sb.Len() == 0 {
399 sb.WriteString("New predictions: ") 452 sb.WriteString(header)
400 } else { 453 } else {
401 sb.WriteString("; ") 454 sb.WriteString("; ")
402 } 455 }
403 fmt.Fprintf(&sb, "%s (%d)", gl.gid, gl.predictions) 456 fmt.Fprintf(&sb, "%s (%d)", gl.gid, v)
404 } 457 }
405 } 458 }
406 if sb.Len() > 0 { 459 if sb.Len() > 0 {
407 feedback.Info(sb.String()) 460 log(sb.String())
408 } 461 }
409 } 462 }
410 463
411 func (gls gmLogs) logIgnoredMeasureCodes(feedback Feedback) { 464 func (gls gmLogs) logString(
465 access func(*gmLog) []string,
466 header string,
467 log func(string, ...interface{}),
468 ) {
412 var sb strings.Builder 469 var sb strings.Builder
413 for _, gl := range gls { 470 for _, gl := range gls {
414 if len(gl.ignoredMeasureCodes) > 0 { 471 if s := access(gl); len(s) > 0 {
415 if sb.Len() == 0 { 472 if sb.Len() == 0 {
416 sb.WriteString("Ignored measure codes: ") 473 sb.WriteString(header)
417 } else { 474 } else {
418 sb.WriteString("; ") 475 sb.WriteString("; ")
419 } 476 }
420 fmt.Fprintf(&sb, "%s (", gl.gid) 477 fmt.Fprintf(&sb, "%s (", gl.gid)
421 for i, mc := range gl.ignoredMeasureCodes { 478 for i, v := range s {
422 if i > 0 { 479 if i > 0 {
423 sb.WriteString(", ") 480 sb.WriteString(", ")
424 } 481 }
425 sb.WriteString(mc) 482 sb.WriteString(v)
426 } 483 }
427 sb.WriteByte(')') 484 sb.WriteByte(')')
428 } 485 }
429 } 486 }
430 if sb.Len() > 0 { 487 if sb.Len() > 0 {
431 feedback.Warn(sb.String()) 488 log(sb.String())
432 }
433 }
434
435 func (gls gmLogs) logRescaleErrors(feedback Feedback) {
436 var sb strings.Builder
437 for _, gl := range gls {
438 if len(gl.rescaleErrors) > 0 {
439 if sb.Len() == 0 {
440 sb.WriteString("Cannot convert units: ")
441 } else {
442 sb.WriteString("; ")
443 }
444 fmt.Fprintf(&sb, "%s (", gl.gid)
445 for i, e := range gl.rescaleErrors {
446 if i > 0 {
447 sb.WriteString(", ")
448 }
449 sb.WriteString(e)
450 }
451 sb.WriteByte(')')
452 }
453 }
454 if sb.Len() > 0 {
455 feedback.Error(sb.String())
456 }
457 }
458
459 func (gls gmLogs) logMissingValues(feedback Feedback) {
460 var sb strings.Builder
461 for _, gl := range gls {
462 if len(gl.missingValues) > 0 {
463 if sb.Len() == 0 {
464 sb.WriteString("Missing mandatory values: ")
465 } else {
466 sb.WriteString("; ")
467 }
468 fmt.Fprintf(&sb, "%s (", gl.gid)
469 for i, m := range gl.missingValues {
470 if i > 0 {
471 sb.WriteString(", ")
472 }
473 sb.WriteString(m)
474 }
475 sb.WriteByte(')')
476 }
477 }
478 if sb.Len() > 0 {
479 feedback.Warn(sb.String())
480 }
481 }
482
483 func (gls gmLogs) logBadValues(feedback Feedback) {
484 var sb strings.Builder
485 for _, gl := range gls {
486 if gl.badValues > 0 {
487 if sb.Len() == 0 {
488 sb.WriteString("Ignored measurements with value -99999: ")
489 } else {
490 sb.WriteString("; ")
491 }
492 fmt.Fprintf(&sb, "%s (%d)", gl.gid, gl.badValues)
493 }
494 }
495 if sb.Len() > 0 {
496 feedback.Warn(sb.String())
497 }
498 }
499
500 func (gls gmLogs) logAssumedCM(feedback Feedback) {
501 var sb strings.Builder
502 for _, gl := range gls {
503 if gl.assumedCM > 0 {
504 if sb.Len() == 0 {
505 sb.WriteString("'Unit' not specified. Assuming 'cm': ")
506 } else {
507 sb.WriteString("; ")
508 }
509 fmt.Fprintf(&sb, "%s (%d)", gl.gid, gl.assumedCM)
510 }
511 }
512 if sb.Len() > 0 {
513 feedback.Warn(sb.String())
514 }
515 }
516
517 func (gls gmLogs) logUnknown(feedback Feedback) {
518 var sb strings.Builder
519 for _, gl := range gls {
520 if gl.assumedZPG {
521 if sb.Len() == 0 {
522 sb.WriteString("Cannot find following gauges: ")
523 } else {
524 sb.WriteString("; ")
525 }
526 sb.WriteString(gl.gid)
527 }
528 }
529 if sb.Len() > 0 {
530 feedback.Warn(sb.String())
531 }
532 }
533
534 func (gls gmLogs) logAssumedZPG(feedback Feedback) {
535 var sb strings.Builder
536 for _, gl := range gls {
537 if gl.assumedZPG {
538 if sb.Len() == 0 {
539 sb.WriteString("'Reference_code' not specified. Assuming 'ZPG': ")
540 } else {
541 sb.WriteString("; ")
542 }
543 sb.WriteString(gl.gid)
544 }
545 }
546 if sb.Len() > 0 {
547 feedback.Info(sb.String())
548 } 489 }
549 } 490 }
550 491
551 // logFinder is a helper to search recently used logs 492 // logFinder is a helper to search recently used logs
552 // or create a new one if no log for a given gauge 493 // or create a new one if no log for a given gauge
617 continue 558 continue
618 } 559 }
619 log := findLog(curr) 560 log := findLog(curr)
620 gids = append(gids, curr) 561 gids = append(gids, curr)
621 562
622 //feedback.Info("Found measurements/predictions for %s", curr)
623 if !isKnown(curr) { 563 if !isKnown(curr) {
624 log.unknown = true 564 log.unknown = true
625 // feedback.Warn("Cannot find gauge %q for import", curr)
626 continue 565 continue
627 } 566 }
628 567
629 var referenceCode string 568 var referenceCode string
630 if wrm.Reference_code == nil { 569 if wrm.Reference_code == nil {
631 //feedback.Info("'Reference_code' not specified. Assuming 'ZPG'")
632 log.assumedZPG = true 570 log.assumedZPG = true
633 referenceCode = "ZPG" 571 referenceCode = "ZPG"
634 } else { 572 } else {
635 referenceCode = string(*wrm.Reference_code) 573 referenceCode = string(*wrm.Reference_code)
636 } 574 }
637 575
638 //badValue := 0
639 //newM, newP := 0, 0
640 for _, measure := range wrm.Measure { 576 for _, measure := range wrm.Measure {
641 var unit string 577 var unit string
642 if *measure.Measure_code != nts.Measure_code_enumWAL { 578 if *measure.Measure_code != nts.Measure_code_enumWAL {
643 log.ignoreMeasureCode(*measure.Measure_code) 579 log.ignoreMeasureCode(*measure.Measure_code)
644 //feedback.Warn("Ignored message with measure_code %s",
645 // *measure.Measure_code)
646 continue 580 continue
647 } 581 }
648 if measure.Unit == nil { 582 if measure.Unit == nil {
649 //feedback.Info("'Unit' not specified. Assuming 'cm'")
650 log.assumedCM++ 583 log.assumedCM++
651 unit = "cm" 584 unit = "cm"
652 } else { 585 } else {
653 unit = string(*measure.Unit) 586 unit = string(*measure.Unit)
654 } 587 }
749 default: 682 default:
750 log.measurements++ 683 log.measurements++
751 } 684 }
752 } 685 }
753 } 686 }
754 //if badValue > 0 {
755 // feedback.Warn("Ignored %d measurements with value -99999",
756 // badValue)
757 //}
758 //feedback.Info("Inserted %d measurements for %s",
759 // newM, curr)
760 //feedback.Info("Inserted %d predictions for %s",
761 // newP, curr)
762 } 687 }
763 } 688 }
764 return gids, nil 689 return gids, nil
765 } 690 }