def check_call(args,
stdin=None,
stdout=None,
stderr=None,
shell=False,
cwd=None,
env=None,
*popenargs,
**popenkw):
cmd = _pre_call(args)
try:
return _check_call(args,
stdin=stdin,
stdout=stdout,
stderr=stderr,
shell=shell,
cwd=cwd,
env=env,
*popenargs,
**popenkw)
except CalledProcessError as e:
get_logger().debug("Command %s returned exit code %s." %
(cmd, e.returncode))
raise
def _pre_call(args):
#needed for chroot safety
import encodings.string_escape
cmd = ' '.join(args)
get_logger().debug("running %s" % (cmd, ))
return cmd
def check_output(args,
stdin=None,
stderr=STDOUT,
shell=False,
cwd=None,
env=None,
*popenargs,
**popenkw):
cmd = _pre_call(args)
try:
return _check_output(args,
stdin=stdin,
stderr=stderr,
shell=shell,
cwd=cwd,
env=env,
*popenargs,
**popenkw)
except CalledProcessError as e:
get_logger().debug(
"Command %s returned exit code %s. This is the programs output:\n%s<<EOF>>"
% (cmd, e.returncode, e.output))
raise
from openmtc_onem2m.serializer.base import OneM2MDictSerializer
from json import JSONEncoder
from futile.logging import get_logger
from datetime import datetime
from openmtc_onem2m.model import ContentInstance
logger = get_logger(__name__)
# rst: ujson and yajl are not supporting object_hooks, but conversion is needed
# rst: some measurements are necessary what is better
# try:
# from ujson import load, loads
# logger.debug("using ujson for decoding JSON")
# except ImportError:
# try:
# from yajl import load, loads
# logger.debug("using yajl for decoding JSON")
# except ImportError:
try:
# simplejson is faster on decoding, tiny bit slower on encoding
from simplejson import load, loads
logger.debug("using simplejson for decoding JSON")
except ImportError:
logger.debug("using builtin json for decoding JSON")
from json import load, loads
del logger
def _default(x):
if isinstance(x, datetime):
if __name__ == "__main__":
from futile.logging import get_logger, INFO, set_default_level
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
USE_IPV6 = True
set_default_level(INFO)
logger = get_logger(__name__, INFO)
parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
parser.add_argument("-p",
"--port",
type=int,
default=8888,
help="port to run on")
# parser.add_argument("-v", "--verbose", action="count", default=None,
# help="Increase verbosity in output. This option can be
# specified multiple times.")
args = parser.parse_args()
class Handler(BaseHTTPRequestHandler):
def do_GET(self):
print("Request received:")
print(self.requestline)
print(self.headers)
print
status_code = 204
response = "OK"
try:
l = int(self.headers["Content-Length"])
# Called with coapurl.sh
import sys
from urlparse import urlparse
from argparse import ArgumentParser
from coap import CoapClient
from coap.coapy.coapy import constants
from futile.logging import get_logger, DEBUG, INFO, WARNING
VALID_HEADERS = ['accept', 'content-format']
# if debug is necessary
# import logging
# logging.basicConfig(level=logging.DEBUG)
logger = get_logger("coapurl")
description = "A simple CoAP command line client inspired by curl."
parser = ArgumentParser(description=description, add_help=True)
parser.add_argument("--version", action='version')
parser.add_argument("-X",
"--request",
choices=("GET", "POST", "PUT", "DELETE"),
help="Specify request command to use.")
parser.add_argument("-d", "--data", help="CoAP POST data")
parser.add_argument("-H",
"--header",
action="append",
help="Custom header to pass to server.")
from futile.net.http.client.RestClient import RestClient
from importlib import import_module
import sys
from openmtc_etsi.serializer.xml import XMLSerializer
from pprint import pprint
from traceback import print_stack
SCL_URI = "http://localhost:4000"
client = RestClient(SCL_URI,
content_type="application/xml",
headers={"Accept": "application/xml"})
futile.logging.set_default_level(DEBUG)
logger = get_logger(__name__, DEBUG)
serializer = XMLSerializer()
specs = []
for importer, modname, ispkg in pkgutil.iter_modules(spec.__path__):
specs.append(modname)
specs.sort()
def test(mod):
try:
if not do_test(mod):
print "Test failed"
try:
from blist import sortedlist
except ImportError:
from futile.logging import get_logger
from heapq import heappush, heappop, heapify
get_logger(__name__).warning(
"blist.sortedlist is not available. Using a fallback implementation")
class sortedlist(object):
def __init__(self, iterable=(), *args, **kw):
super(sortedlist, self).__init__(*args, **kw)
l = self._list = list(iterable)
if iterable is not None:
heapify(l)
def add(self, v):
heappush(self._list, v)
def pop(self, index=-1):
if index != 0:
raise NotImplementedError()
return heappop(self._list)
def remove(self, object):
self._list.remove(object)
heapify(self._list)
from futile.logging import get_logger
get_logger(__name__).warning("Deprecated import")
from openmtc_gevent.ServerRack import GEventServerRack
