vitalif
/
imposm3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fixed parsing of diff command options

master
Oliver Tonnhofer 2013-07-26 15:59:03 +02:00
parent 4c7fefb52b
commit 04714e266c
3 changed files with 103 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
config/config.go
View File

@ -19,12 +19,12 @@ type Config struct {
const defaultSrid = 3857
const defaultCacheDir = "/tmp/goposm"
var ImportFlags = flag.NewFlagSet("import", flag.ContinueOnError)
var DiffImportFlags = flag.NewFlagSet("diff", flag.ContinueOnError)
var ImportFlags = flag.NewFlagSet("import", flag.ExitOnError)
var DiffImportFlags = flag.NewFlagSet("diff", flag.ExitOnError)
type ImportBaseOptions struct {
Connection string
Cachedir string
CacheDir string
MappingFile string
Srid int
LimitTo string
@ -57,7 +57,7 @@ var DiffImportOptions = _DiffImportOptions{}
func addBaseFlags(flags *flag.FlagSet, baseOptions *ImportBaseOptions) {
flags.StringVar(&baseOptions.Connection, "connection", "", "connection parameters")
flags.StringVar(&baseOptions.Cachedir, "cachedir", defaultCacheDir, "cache directory")
flags.StringVar(&baseOptions.CacheDir, "cachedir", defaultCacheDir, "cache directory")
flags.StringVar(&baseOptions.MappingFile, "mapping", "", "mapping file")
flags.IntVar(&baseOptions.Srid, "srid", defaultSrid, "srs id")
flags.StringVar(&baseOptions.LimitTo, "limitto", "", "limit to geometries")
@ -100,60 +100,85 @@ func init() {
// configFile = flag.String("config", "", "config (json)")
// )
func Parse(args []string) (*Config, []error) {
func ParseImport(args []string) []error {
err := ImportFlags.Parse(args)
if err != nil {
log.Fatal(err)
}
errs := updateBaseOpts(&ImportOptions.Base)
if errs != nil {
return errs
}
config := &Config{
errs = checkOptions(&ImportOptions.Base)
return errs
}
func updateBaseOpts(opts *ImportBaseOptions) []error {
conf := &Config{
CacheDir: defaultCacheDir,
Srid: defaultSrid,
}
if ImportOptions.Base.ConfigFile != "" {
f, err := os.Open(ImportOptions.Base.ConfigFile)
if opts.ConfigFile != "" {
f, err := os.Open(opts.ConfigFile)
if err != nil {
return nil, []error{err}
return []error{err}
}
decoder := json.NewDecoder(f)
err = decoder.Decode(&config)
err = decoder.Decode(&conf)
if err != nil {
return nil, []error{err}
return []error{err}
}
}
if ImportOptions.Base.Connection != "" {
config.Connection = ImportOptions.Base.Connection
if opts.Connection == "" {
opts.Connection = conf.Connection
}
if config.Srid == 0 {
config.Srid = defaultSrid
if conf.Srid == 0 {
conf.Srid = defaultSrid
}
if ImportOptions.Base.Srid != defaultSrid {
config.Srid = ImportOptions.Base.Srid
if opts.Srid != defaultSrid {
opts.Srid = conf.Srid
}
if ImportOptions.Base.MappingFile != "" {
config.MappingFile = ImportOptions.Base.MappingFile
if opts.MappingFile == "" {
opts.MappingFile = conf.MappingFile
}
if ImportOptions.Base.LimitTo != "" {
config.LimitTo = ImportOptions.Base.LimitTo
if opts.LimitTo == "" {
opts.LimitTo = conf.LimitTo
}
if ImportOptions.Base.Cachedir != defaultCacheDir {
config.CacheDir = ImportOptions.Base.Cachedir
if opts.CacheDir == defaultCacheDir {
opts.CacheDir = conf.CacheDir
}
errs := checkConfig(config)
return config, errs
return nil
}
func checkConfig(config *Config) []error {
func ParseDiffImport(args []string) []error {
err := DiffImportFlags.Parse(args)
if err != nil {
log.Fatal(err)
}
errs := updateBaseOpts(&DiffImportOptions.Base)
if errs != nil {
return errs
}
errs = checkOptions(&DiffImportOptions.Base)
return errs
}
func checkOptions(opts *ImportBaseOptions) []error {
errs := []error{}
if config.Srid != 3857 {
if opts.Srid != 3857 {
errs = append(errs, errors.New("srid!=3857 not implemented"))
}
if config.MappingFile == "" {
if opts.MappingFile == "" {
errs = append(errs, errors.New("missing mapping"))
}
if config.Connection == "" {
if opts.Connection == "" {
errs = append(errs, errors.New("missing connection"))
}
return errs

26
diff/cmd/process.go
View File

@ -21,17 +21,17 @@ import (
var log = logging.NewLogger("")
func Update(oscFile string, conf *config.Config, force bool) {
func Update(oscFile string, force bool) {
state, err := diffstate.ParseFromOsc(oscFile)
if err != nil {
log.Fatal(err)
}
lastState, err := diffstate.ParseLastState(conf.CacheDir)
lastState, err := diffstate.ParseLastState(config.DiffImportOptions.Base.CacheDir)
if err != nil {
log.Fatal(err)
}
if lastState != nil && lastState.Sequence != 0 && state.Sequence <= lastState.Sequence {
if lastState != nil && lastState.Sequence != 0 && state != nil && state.Sequence <= lastState.Sequence {
if !force {
log.Warn(state, " already imported")
return
@ -42,28 +42,28 @@ func Update(oscFile string, conf *config.Config, force bool) {
elems, errc := parser.Parse(oscFile)
osmCache := cache.NewOSMCache(conf.CacheDir)
osmCache := cache.NewOSMCache(config.DiffImportOptions.Base.CacheDir)
err = osmCache.Open()
if err != nil {
log.Fatal("osm cache: ", err)
}
diffCache := cache.NewDiffCache(conf.CacheDir)
diffCache := cache.NewDiffCache(config.DiffImportOptions.Base.CacheDir)
err = diffCache.Open()
if err != nil {
log.Fatal("diff cache: ", err)
}
tagmapping, err := mapping.NewMapping(conf.MappingFile)
tagmapping, err := mapping.NewMapping(config.DiffImportOptions.Base.MappingFile)
if err != nil {
log.Fatal(err)
}
connType := database.ConnectionType(conf.Connection)
connType := database.ConnectionType(config.DiffImportOptions.Base.Connection)
dbConf := database.Config{
Type: connType,
ConnectionParams: conf.Connection,
Srid: conf.Srid,
ConnectionParams: config.DiffImportOptions.Base.Connection,
Srid: config.DiffImportOptions.Base.Srid,
}
db, err := database.Open(dbConf, tagmapping)
if err != nil {
@ -107,19 +107,19 @@ func Update(oscFile string, conf *config.Config, force bool) {
nodes := make(chan *element.Node)
relWriter := writer.NewRelationWriter(osmCache, diffCache, relations,
db, polygonsTagMatcher, progress, conf.Srid)
db, polygonsTagMatcher, progress, config.DiffImportOptions.Base.Srid)
relWriter.SetClipper(geometryClipper)
relWriter.SetExpireTiles(expiredTiles)
relWriter.Start()
wayWriter := writer.NewWayWriter(osmCache, diffCache, ways, db,
lineStringsTagMatcher, polygonsTagMatcher, progress, conf.Srid)
lineStringsTagMatcher, polygonsTagMatcher, progress, config.DiffImportOptions.Base.Srid)
wayWriter.SetClipper(geometryClipper)
wayWriter.SetExpireTiles(expiredTiles)
wayWriter.Start()
nodeWriter := writer.NewNodeWriter(osmCache, nodes, db,
pointsTagMatcher, progress, conf.Srid)
pointsTagMatcher, progress, config.DiffImportOptions.Base.Srid)
nodeWriter.SetClipper(geometryClipper)
nodeWriter.Start()
@ -277,7 +277,7 @@ For:
log.StopStep(step)
progress.Stop()
err = diffstate.WriteLastState(conf.CacheDir, state)
err = diffstate.WriteLastState(config.DiffImportOptions.Base.CacheDir, state)
if err != nil {
log.Warn(err) // warn only
}

61
goposm.go
View File

@ -33,6 +33,15 @@ func dief(msg string, args ...interface{}) {
log.Fatalf(msg, args...)
}
func reportErrors(errs []error) {
log.Warn("errors in config/options:")
for _, err := range errs {
log.Warnf("\t%s", err)
}
logging.Shutdown()
os.Exit(1)
}
func main() {
golog.SetFlags(golog.LstdFlags | golog.Lshortfile)
@ -44,22 +53,22 @@ func main() {
os.Exit(1)
}
conf, errs := config.Parse(os.Args[2:])
if len(errs) > 0 {
log.Warn("errors in config/options:")
for _, err := range errs {
log.Warnf("\t%s", err)
}
logging.Shutdown()
os.Exit(1)
}
switch os.Args[1] {
case "import":
mainimport(conf)
errs := config.ParseImport(os.Args[2:])
if len(errs) > 0 {
reportErrors(errs)
break
}
mainimport()
case "diff":
errs := config.ParseDiffImport(os.Args[2:])
if len(errs) > 0 {
reportErrors(errs)
break
}
for _, oscFile := range config.DiffImportFlags.Args() {
cmd.Update(oscFile, conf, false)
cmd.Update(oscFile, false)
}
default:
log.Fatal("invalid command")
@ -69,7 +78,7 @@ func main() {
}
func mainimport(conf *config.Config) {
func mainimport() {
if config.ImportOptions.Cpuprofile != "" {
f, err := os.Create(config.ImportOptions.Cpuprofile)
if err != nil {
@ -113,21 +122,21 @@ func mainimport(conf *config.Config) {
}
var geometryClipper *clipper.Clipper
if config.ImportOptions.Write && conf.LimitTo != "" {
if config.ImportOptions.Write && config.ImportOptions.Base.LimitTo != "" {
var err error
step := log.StartStep("Reading limitto geometries")
geometryClipper, err = clipper.NewFromOgrSource(conf.LimitTo)
geometryClipper, err = clipper.NewFromOgrSource(config.ImportOptions.Base.LimitTo)
if err != nil {
die(err)
}
log.StopStep(step)
}
osmCache := cache.NewOSMCache(conf.CacheDir)
osmCache := cache.NewOSMCache(config.ImportOptions.Base.CacheDir)
if config.ImportOptions.Read != "" && osmCache.Exists() {
if config.ImportOptions.Overwritecache {
log.Printf("removing existing cache %s", conf.CacheDir)
log.Printf("removing existing cache %s", config.ImportOptions.Base.CacheDir)
err := osmCache.Remove()
if err != nil {
die("unable to remove cache:", err)
@ -139,7 +148,7 @@ func mainimport(conf *config.Config) {
progress := stats.StatsReporter()
tagmapping, err := mapping.NewMapping(conf.MappingFile)
tagmapping, err := mapping.NewMapping(config.ImportOptions.Base.MappingFile)
if err != nil {
die("mapping file: ", err)
}
@ -147,11 +156,11 @@ func mainimport(conf *config.Config) {
var db database.DB
if config.ImportOptions.Write || config.ImportOptions.DeployProduction || config.ImportOptions.RevertDeploy || config.ImportOptions.RemoveBackup || config.ImportOptions.Optimize {
connType := database.ConnectionType(conf.Connection)
connType := database.ConnectionType(config.ImportOptions.Base.Connection)
conf := database.Config{
Type: connType,
ConnectionParams: conf.Connection,
Srid: conf.Srid,
ConnectionParams: config.ImportOptions.Base.Connection,
Srid: config.ImportOptions.Base.Srid,
}
db, err = database.Open(conf, tagmapping)
if err != nil {
@ -183,7 +192,7 @@ func mainimport(conf *config.Config) {
if config.ImportOptions.Diff {
diffstate := state.FromPbf(pbfFile)
if diffstate != nil {
diffstate.WriteToFile(path.Join(conf.CacheDir, "last.state.txt"))
diffstate.WriteToFile(path.Join(config.ImportOptions.Base.CacheDir, "last.state.txt"))
}
}
}
@ -209,7 +218,7 @@ func mainimport(conf *config.Config) {
var diffCache *cache.DiffCache
if config.ImportOptions.Diff {
diffCache = cache.NewDiffCache(conf.CacheDir)
diffCache = cache.NewDiffCache(config.ImportOptions.Base.CacheDir)
if err = diffCache.Remove(); err != nil {
die(err)
}
@ -229,7 +238,7 @@ func mainimport(conf *config.Config) {
relations := osmCache.Relations.Iter()
relWriter := writer.NewRelationWriter(osmCache, diffCache, relations,
db, polygonsTagMatcher, progress, conf.Srid)
db, polygonsTagMatcher, progress, config.ImportOptions.Base.Srid)
relWriter.SetClipper(geometryClipper)
relWriter.Start()
@ -239,7 +248,7 @@ func mainimport(conf *config.Config) {
ways := osmCache.Ways.Iter()
wayWriter := writer.NewWayWriter(osmCache, diffCache, ways, db,
lineStringsTagMatcher, polygonsTagMatcher, progress, conf.Srid)
lineStringsTagMatcher, polygonsTagMatcher, progress, config.ImportOptions.Base.Srid)
wayWriter.SetClipper(geometryClipper)
wayWriter.Start()
@ -249,7 +258,7 @@ func mainimport(conf *config.Config) {
nodes := osmCache.Nodes.Iter()
nodeWriter := writer.NewNodeWriter(osmCache, nodes, db,
pointsTagMatcher, progress, conf.Srid)
pointsTagMatcher, progress, config.ImportOptions.Base.Srid)
nodeWriter.SetClipper(geometryClipper)
nodeWriter.Start()