Ejemplo n.º 1
0
    def add(self, method, route, obj, name=None):
        if re.search('\s', route):
            raise ValueError('Route may not include whitespace.')
        fields = re.findall('{([^}]*)}', route)
        for field in fields:
            is_identifier = re.match('[A-Za-z_][A-Za-z0-9_]+$', field)
            if not is_identifier or field in keyword.kwlist:
                raise ValueError('Field names must be valid identifiers.')

        route = route.strip('/')
        if self._match(method, route) is None:
            r = []
            r.append(method)
            r.append(route)
            r.append(obj)
            r.append(name)
            self.routes.append(r)
        else:
            raise nfw.Error('Adding duplicate API route %s' % (route))
Ejemplo n.º 2
0
def createDevicePost(req, resp):
    api = RestClient(req.context['restapi'])
    values = req.post
    subnet = values.get('device_ip')
    data = {'snmp_comm': values.get('snmp_community')}
    issubnet = re.search('/', subnet)
    if not issubnet:
        subnet += "/32"
        try:
            subnet = IPNetwork(subnet)
        except e:
            raise (nfw.Error(e))
    results = []
    for ip in subnet:
        ver = ip._version
        ip = ip.ip_network
        data['id'] = ip2dec(ip, 4)
        response_headers, result = api.execute(
            nfw.HTTP_POST, "/infrastructure/network/devices", obj=data)
        results.append(result)
    return results
Ejemplo n.º 3
0
    def __init__(self, config_file=None):
        self.config = {}
        if config_file is None:
            config_file = nfw_config

        if config_file is not None:
            if os.path.isfile(config_file):
                if config_file not in self.configs:
                    config = ConfigParser.ConfigParser()
                    config.read(config_file)
                    sections = config.sections()
                    for s in sections:
                        self.config[s] = Section()
                        options = config.options(s)
                        for o in options:
                            self.config[s][o] = config.get(s, o)
                    self.configs[config_file] = self.config
                else:
                    self.config = self.configs[config_file]
            else:
                raise nfw.Error("Configuration file not found: %s"
                                % (config_file,))
Ejemplo n.º 4
0
# 	nfw.config.nfw_config = os.environ['NEUTRINO_CONFIG']
#    else:
# 	raise nfw.Error("Configuration file not found: %s"
# 				% (os.environ['NEUTRINO_CONFIG'],))
# else:
#    raise nfw.Error("Configuration file not found in os.environment")

celeryConfPath = '/etc/netrino-celery.cfg'

config = nfw.Config(celeryConfPath)

try:
    celery = config.get('celery')
    app = Celery(celery.get('app'),
                 broker=celery.get('broker'),
                 backend=celery.get('backend'),
                 include=celery.get('include').split(','))

    app.conf.update(result_expires=celery.get('result_expires'))
except:
    raise nfw.Error("No Celery settings found in %s" % celeryConfPath)

try:
    mysql = config.get('mysql')
    db = nfw.Mysql(host=mysql.get('host'),
                   database=mysql.get('database'),
                   username=mysql.get('username'),
                   password=mysql.get('password'))
except:
    raise nfw.Error("No Celery settings found in %s" % celeryConfPath)
Ejemplo n.º 5
0
    def __init__(self, data=None, validate=True, readonly=False, **kwargs):
        super(nfw.ModelDict, self).__init__(**kwargs)

        if validate is True:
            load = False
        else:
            load = True

        self.readonly = readonly

        if isinstance(data, nfw.Request):
            values = {}
            for v in data.post:
                values[v] = data.post[v].value
        elif isinstance(data, dict):
            values = data
        else:
            raise nfw.Error('forms only accept request or dict object')
        try:
            if values is not None:
                for v in values:
                    if hasattr(self, v):
                        t = v.replace('_confirm', '')
                        field = getattr(self, t)
                        if field.label is not None:
                            name = field.label
                        else:
                            name = v
                    if '_confirm' in v:
                        t = v.replace('_confirm', '')
                        field = getattr(self, t)
                        if field.label is not None:
                            name = field.label
                        else:
                            name = v
                        if values[t] is None or values[t] == '':
                            if values[v] is not None and values[v] != '':
                                raise nfw.HTTPBadRequest(
                                    title="Field Invalid",
                                    description="%s mis-match" % (name, ))
                    if hasattr(self, v):
                        if ((values[v] is not None and values[v] != '')
                                or field.required is True):
                            if field.readonly is False:
                                if isinstance(field, nfw.ModelDict.Bool):
                                    self._set({v: True}, load)
                                elif isinstance(field, nfw.ModelDict.Password):
                                    confirm = "%s_confirm" % (v)
                                    if confirm in values:
                                        if load is False:
                                            c = values[confirm]
                                            if c != values[v]:
                                                raise nfw.HTTPBadRequest(
                                                    title="Field Invalid",
                                                    description="%s mis-match"
                                                    % (name, ))
                                    self._set({v: values[v]}, load)
                                elif isinstance(field, nfw.ModelDict.Integer):
                                    try:
                                        self._set({v: long(values[v])}, load)
                                    except:
                                        self._set({v: values[v].value}, load)
                                elif isinstance(field, nfw.ModelDict.Number):
                                    try:
                                        self._set({v: float(values[v])}, load)
                                    except:
                                        self._set({v: values[v]}, load)
                                else:
                                    self._set({v: values[v]}, load)
        except nfw.FieldError as e:
            raise nfw.HTTPBadRequest(title="Field Invalid", description=e)
Ejemplo n.º 6
0
    def execute(self, method, url, data=None, headers=[]):
        import pycurl
        host = self.get_host_port_from_url(url)
        if host in self.curl_session:
            curl = self.curl_session[host]
        else:
            self.curl_session[host] = pycurl.Curl()
            curl = self.curl_session[host]

        url = url.replace(" ", "%20")

        method = method.upper()

        self.server_headers = dict()

        buffer = BytesIO()

        curl.setopt(curl.URL, nfw.utils.if_unicode_to_utf8(url))
        try:
            curl.setopt(curl.WRITEDATA, buffer)
        except TypeError:
            curl.setopt(curl.WRITEFUNCTION, buffer.write)
        curl.setopt(curl.HEADERFUNCTION, self.header_function)
        curl.setopt(curl.FOLLOWLOCATION, True)
        curl.setopt(curl.SSL_VERIFYPEER, self.ssl_verify_peer)
        curl.setopt(curl.SSL_VERIFYHOST, self.ssl_verify_host)
        curl.setopt(curl.CONNECTTIMEOUT, self.connect_timeout)
        curl.setopt(curl.TIMEOUT, self.timeout)
        curl.setopt(curl.DEBUGFUNCTION, _debug)
        curl.setopt(curl.VERBOSE, 1)

        if data is not None:
            curl.setopt(curl.POSTFIELDS, nfw.utils.if_unicode_to_utf8(data))
        else:
            curl.setopt(curl.POSTFIELDS, nfw.utils.if_unicode_to_utf8(''))

        send_headers = list()
        for header in headers:
            send_header = nfw.utils.if_unicode_to_utf8(
                "%s: %s" % (header, headers[header]))
            send_headers.append(send_header)

        curl.setopt(pycurl.HTTPHEADER, send_headers)

        if method == nfw.HTTP_GET:
            curl.setopt(curl.CUSTOMREQUEST,
                        nfw.utils.if_unicode_to_utf8('GET'))
        elif method == nfw.HTTP_PUT:
            curl.setopt(curl.CUSTOMREQUEST,
                        nfw.utils.if_unicode_to_utf8('PUT'))
        elif method == nfw.HTTP_POST:
            curl.setopt(curl.CUSTOMREQUEST,
                        nfw.utils.if_unicode_to_utf8('POST'))
        elif method == nfw.HTTP_PATCH:
            curl.setopt(curl.CUSTOMREQUEST,
                        nfw.utils.if_unicode_to_utf8('PATCH'))
        elif method == nfw.HTTP_DELETE:
            curl.setopt(curl.CUSTOMREQUEST,
                        nfw.utils.if_unicode_to_utf8('DELETE'))
        elif method == nfw.HTTP_OPTIONS:
            curl.setopt(curl.CUSTOMREQUEST,
                        nfw.utils.if_unicode_to_utf8('OPTIONS'))
        elif method == nfw.HTTP_HEAD:
            curl.setopt(curl.CUSTOMREQUEST,
                        nfw.utils.if_unicode_to_utf8('HEAD'))
        elif method == nfw.HTTP_TRACE:
            curl.setopt(curl.CUSTOMREQUEST,
                        nfw.utils.if_unicode_to_utf8('TRACE'))
        elif method == nfw.HTTP_CONNECT:
            curl.setopt(curl.CUSTOMREQUEST,
                        nfw.utils.if_unicode_to_utf8('CONNECT'))
        else:
            raise nfw.Error("Invalid request type %s" % (method, ))

        try:
            curl.perform()
            status = curl.getinfo(pycurl.HTTP_CODE)
        except pycurl.error as e:
            del self.curl_session[host]
            if e[0] == 28:
                raise nfw.RestClientError("Connection timeout %s" % (host, ))
            else:
                raise pycurl.error(e)

        # Figure out what encoding was sent with the response, if any.
        # Check against lowercased header name.
        encoding = None
        if 'content-type' in self.server_headers:
            content_type = self.server_headers['content-type'].lower()
            match = re.search('charset=(\S+)', content_type)
            if match:
                encoding = match.group(1)
        if encoding is None:
            # Default encoding for JSON is UTF-8.
            # Other content types may have different default encoding,
            # or in case of binary data, may have no encoding at all.
            encoding = 'utf_8'

        body = buffer.getvalue()
        # Decode using the encoding we figured out.
        body = body.decode(encoding)
        resp_header = nfw.Headers()
        for h in self.server_headers:
            resp_header[h] = self.server_headers[h]
        return (status, resp_header, body)