#!/usr/bin/env python2.7

# -*- coding: utf-8 -*-

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

# #

# QGIS Rest Publisher is a QGIS plugin that facilitates exporting or #

# importing from remote servers with a REST API. #

# #

# Copyright (C) 2011-2013 Neogeo Technologies. #

# #

# This file is part of QGIS Rest Publisher. #

# #

# QGIS Rest Publisher is free software: you can redistribute it #

# and/or modify it under the terms of the GNU General Public License #

# as published by the Free Software Foundation, either version 3 of #

# the License, or (at your option) any later version. #

# #

# QGIS Rest Publisher is distributed in the hope that it will be #

# useful, but WITHOUT ANY WARRANTY; without even the implied warranty #

# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #

# GNU General Public License for more details. #

# #

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

import functools

import httplib

import urlparse

import json

import pdb

import inspect

import sys

import textwrap

import collections

import urllib2

import pprint

import contextlib

import base64

import pyxml

from pyxml import Entries

class HTTPError(httplib.HTTPException):

httplib.HTTPException.__init__(self, "[%d] %s" % (self.response.status, self.response.reason))

# Some small helpers.

def rmOuterDict(data):

return req, data

class apixml():

return pyxml.loads(x)

apixml = apixml()

# This API aims to be CRUD.

# The main verbs used are: create, get, update, delete

class RestAPI(object):

}

# The following classes are here to provide an easy way to patch

# the protocols beeing used, in order to fix some disparities

# between MRA and the Geoserver REST API before they are beeing

# changed in either one of those.

class MRA(RestAPI):

# Everything is the same \o/ (Should be.)

pass

class geoserverREST(RestAPI):

raise e

# If this is used as a stand alone client we need to get arguments

# from the command line and have some application logic.

if __name__ == '__main__':

import argparse

parser = argparse.ArgumentParser()

action = parser.add_argument_group("actions", "This options indicate the main action to be performed. "

"It basically mirrors the CRUD API."

).add_mutually_exclusive_group()

action.add_argument("--create", action="store_const", const="create", dest="action")

action.add_argument("--get", action="store_const", const="get", dest="action")

action.add_argument("--update", action="store_const", const="update", dest="action")

action.add_argument("--delete", action="store_const", const="delete", dest="action")

action.add_argument("--map", action="store_const", const="map", dest="action")

action.set_defaults(action="get")

selection = parser.add_argument_group("specifiers", "This options can be used to specify on what "

"resources you want to operate.")

selection.add_argument("-ws", "--workspace", dest="ws_name", nargs="?", default=argparse.SUPPRESS)

selection.add_argument("-s", "--style", dest="s_name", nargs="?", default=argparse.SUPPRESS)

selection.add_argument("-l", "--layer", dest="l_name", nargs="?", default=argparse.SUPPRESS)

selection.add_argument("-lg", "--layergroup", dest="lg_name", nargs="?", default=argparse.SUPPRESS)

selection.add_argument("-cs", "--coveragestore", dest="cs_name", nargs="?", default=argparse.SUPPRESS)

selection.add_argument("-ds", "--datastore", dest="ds_name", nargs="?", default=argparse.SUPPRESS)

selection.add_argument("-c", "--coverage", dest="c_name", nargs="?", default=argparse.SUPPRESS)

selection.add_argument("-ft", "--featuretype", dest="ft_name", nargs="?", default=argparse.SUPPRESS)

selection.add_argument("-ff", "--ffile", dest="ffile", default=argparse.SUPPRESS, type=argparse.FileType("r"))

selection.add_argument("-cf", "--cfile", dest="cfile", default=argparse.SUPPRESS, type=argparse.FileType("r"))

data = parser.add_argument_group("data", "This options allow for input data to be specified. "

"It is intended to be used with actions such as --create")

data.add_argument("-f", "--file", type=argparse.FileType("r"))

data.add_argument("-i", "--input", choices=["json", "xml"], default="xml")

data.add_argument("-ct", "--content-type", default=argparse.SUPPRESS)

data.add_argument("--ext", default=argparse.SUPPRESS)

data.add_argument("-r", "--resource", default=argparse.SUPPRESS)

api = parser.add_argument_group("api", "This arguments are used when comunicating with the remote API.")

api.add_argument("url")

api.add_argument("-o", "--output", choices=["json", "xml"], default="xml")

api.add_argument("-t", "--tweak-for", choices=["mra", "geoserver"])

api.add_argument("-v", "--verbose", action="store_true")

api.add_argument("-u", "--user", default=None)

api.add_argument("-p", "--password", default=None)

args = parser.parse_args()

if not args.url.endswith("/"):

print >> sys.stderr, "Warning: Appending '/' to base url."

args.url += "/"

# Build the API.

tweakers = {"mra": MRA, "geoserver": geoserverREST}

tweaker = tweakers.get(args.tweak_for, RestAPI)

api = tweaker(args.url, encoding=args.output, verbose=args.verbose, username=args.user, password=args.password)

# Now I am not really interested in a bunch of ifs. Lets do it the easy way.

# This dict is used to translate argument names to object names.

possible = collections.OrderedDict((("ws_name", "workspace"),

("s_name", "style"),

("lg_name", "layergroup"),

("cs_name", "coveragestore"),

("ds_name", "datastore"),

("c_name", "coverage"),

("ft_name", "featuretype"),

("l_name", "layer"),

("ffile", "ffile"),

("cfile", "cfile"),

))

# First we need to know what the user is interested in, that's the most deep level of specifier.

what = next((x for x in reversed(possible) if x in args), None)

if what:

# Now, which of what do we want?

which = getattr(args, what)

# But, what is what?

whatis = possible[what]

# If we don't know which which we want as what, we watch for all whats that might be which.

# Unless what we want is to create that which does not yet exists.

if not which and args.action != "create":

whatis += "s"

# Now lets fish for the method.

method = getattr(api, "%s_%s" % (args.action, whatis))

else:

# We don't want anything in particular, lets see if that is possible.

method = getattr(api, "%s" % (args.action))

# Now it gets really tricky, we need to get the right arguments.

# Simply forwarding everything from the user might work but its not complicated enough.

# Actually this way allows us to do error checking, which is always better, isn't it ?

argspec = inspect.getargspec(method)

try:

methodargs = inspect.getcallargs(method, **dict((arg, getattr(args, arg)) for arg in argspec.args if arg in args))

except TypeError as e:

if argspec.defaults:

missing = [x for x in argspec.args[1:-len(argspec.defaults)] if x not in args]

else:

missing = [x for x in argspec.args[1:] if x not in args]

parser.error("Missing parameters: %s" % ", ".join(x.upper() for x in missing))

# dirty fix, but self should not yet be present.

del methodargs["self"]

print >>sys.stderr, "="*70

print >>sys.stderr, "%s(%s)" % (method.__name__, ", ".join("%s=%s" % (n, v) for n, v in methodargs.iteritems()))

print >>sys.stderr, "="*70

try:

# As simple as that.

content = method(**methodargs)

if args.action != "map":

response, content = content

except HTTPError as e:

# Error will have been printed already.

exit(1)

if args.verbose:

print >>sys.stderr, "="*70

pprint.pprint(content)