예제 #1
0
def main(argv=None):
    if not argv:
        argv = sys.argv

    if len(argv) < 2:
        usage(argv)

    load_dotenv_vars()
    env = Env()

    config_uri = argv[1]
    wsgi_app = get_app(config_uri)
    setup_logging(config_uri)

    import cherrypy

    cherrypy.tree.graft(wsgi_app, '/')
    cherrypy.server.unsubscribe()

    from cherrypy._cpserver import Server

    server = Server()
    server.socket_host = env.host
    server.socket_port = env.port
    server.thread_pool = 10
    server.subscribe()

    cherrypy.engine.start()
    cherrypy.engine.block()
예제 #2
0
파일: ooba.py 프로젝트: darkisildur/YAPT
    def __init__(self):
        self._host = c.conf.YAPT.WebUiAddress
        self._port = int(c.conf.YAPT.OobaUiPort)
        self._current_dir = os.path.dirname(os.path.abspath(__file__))

        yapt_rest_server = Server()
        yapt_rest_server.socket_host = self._host
        yapt_rest_server.socket_port = self._port
        yapt_rest_server.subscribe()
예제 #3
0
    def __init__(self):

        self._host = c.conf.YAPT.WebUiAddress
        self._port = int(c.conf.YAPT.WebUiPort)
        self._scheme = 'ws'

        Plugin(cherrypy.engine).subscribe()
        AMQP(cherrypy.engine).subscribe()

        cherrypy.tools.websocket = WebSocketTool()

        yapt_server = Server()
        yapt_server.socket_host = self._host
        yapt_server.socket_port = self._port
        yapt_server.max_request_body_size = 838860800
        yapt_server.subscribe()
예제 #4
0
파일: rest.py 프로젝트: darkisildur/YAPT
    def __init__(self):
        _backendp = BackendClientProcessor(
            exchange='', routing_key=c.AMQP_RPC_BACKEND_QUEUE)
        self._setattr_url_map(args=_backendp)

        _host = c.conf.YAPT.WebUiAddress
        _port = int(c.conf.YAPT.RestApiPort)

        yapt_rest_server = Server()
        yapt_rest_server.socket_host = _host
        yapt_rest_server.socket_port = _port
        yapt_rest_server.subscribe()
        cherrypy.tools.cors_tool = cherrypy.Tool('before_request_body',
                                                 cors_tool,
                                                 name='cors_tool',
                                                 priority=50)
예제 #5
0
def _get_root_start():
    # # Set up path to db file
    db_path = os.path.abspath(os.path.join(os.curdir, rasp_settings.db_file))
    rasphome.database.set_db_path('sqlite:///%s' % db_path)

    # # Set up Admin User name and Default admin user
    # noinspection PyArgumentList
    create_init_db()

    # # Set up Sqlalchemy Plugin and Tool
    rasphome.database.SAEnginePlugin(cherrypy.engine).subscribe()
    cherrypy.tools.db = rasphome.database.SATool()

    # # Activate additional SSL Server
    from cherrypy._cpserver import Server
    server = Server()
    server.socket_host = '0.0.0.0'
    server.socket_port = rasp_settings.https_port
    server.ssl_certificate = './cert.pem'
    server.ssl_private_key = './privatekey.pem'
    server.subscribe()

    # # Do other config
    config = {
        'global' : {
            'server.socket_host' : '0.0.0.0',
            'server.socket_port' : rasp_settings.http_port
        },
        '/' : {
            'tools.auth_basic.on': True,
            'tools.auth_basic.realm': 'earth',
            'tools.auth_basic.checkpassword': rasphome.authorization.checkpassword(),
            'tools.db.on' : True,
            'request.dispatch': cherrypy.dispatch.MethodDispatcher()
        }
    }

    # # Set up Api
    root = rasphome.api.Root()
    root.backend = rasphome.api.Backend_api()
    root.monitor = rasphome.api.Monitor_api()
    root.node = rasphome.api.Node_api()
    root.room = rasphome.api.Room_api()
    root.user = rasphome.api.User_api()

    setUpLogger()
    return root, config
예제 #6
0
def run():
    config = {
        'server.socket_host': '0.0.0.0',
        'server.socket_port': app.config['PORT'],
        'engine.autoreload.on': app.config['AUTO_RELOAD'],
        'log.screen': app.config['DEBUG'],
        'log.error_file': os.path.join(app.config['LOGS_DIR'], 'error.log')
    }
    cherrypy.config.update(config)

    cherrypy.tree.graft(app, '/')

    https_server = Server()
    https_server.socket_host = '0.0.0.0'
    https_server.socket_port = app.config['PORT_SECURE']
    https_server.ssl_module = 'pyopenssl'
    https_server.ssl_certificate = app.config['SSL_PATH']['crt']
    https_server.ssl_private_key = app.config['SSL_PATH']['key']

    https_server.subscribe()
    cherrypy.engine.start()
    cherrypy.engine.block()
예제 #7
0
class WebhookInit(object):

    def __init__(self, normalizer, svc_cfg):
        self.logger = c.logger
        cherrypy.config.update('{0}/{1}'.format(os.getcwd(), c.SVC_WEBHOOK_CONF))

        for module in c.conf.SERVICES.Webhook.Modules:
            handler = getattr(sys.modules[__name__], module + 'WebHookHandler')
            cherrypy.tree.mount(handler(normalizer=normalizer, svc_cfg=svc_cfg),
                                script_name='/' + module.lower(),
                                config='{0}/{1}'.format(os.getcwd(),
                                                        '{0}{1}{2}'.format(c.SVC_WEBHOOK_PATH, module.lower(),
                                                                           '.conf')))
        self._webhook_server = Server()
        self._webhook_server.socket_host = c.conf.SERVICES.Webhook.ServiceBindAddress
        self._webhook_server.socket_port = c.conf.SERVICES.Webhook.ServiceListenPort
        self._webhook_server.subscribe()
        self.logger.info(Tools.create_log_msg(logmsg.WEBHOOK_SERVICE, None,
                                              logmsg.WEBHOOK_LISTEN.format(self._webhook_server.socket_host,
                                                                           self._webhook_server.socket_port)))

        cherrypy.engine.start()
        cherrypy.engine.block()
예제 #8
0
class BackendServer(SmartPlugin):
    ALLOW_MULTIINSTANCE = False
    PLUGIN_VERSION='1.3.5'

    def my_to_bool(self, value, attr='', default=False):
        try:
            result = self.to_bool(value)
        except:
            result = default
            self.logger.error("BackendServer: Invalid value '"+str(value)+"' configured for attribute "+attr+" in plugin.conf, using '"+str(result)+"' instead")
        return result

    def get_local_ip_address(self):
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("10.10.10.10", 80))
        return s.getsockname()[0]

    def __init__(self, sh, port=None, threads=8, ip='', updates_allowed='True', user="******", password="", hashed_password="", language="", developer_mode="no", pypi_timeout=5):
        self.logger = logging.getLogger(__name__)
        self._user = user
        self._password = password
        self._hashed_password = hashed_password

        if self._password is not None and self._password != "" and self._hashed_password is not None and self._hashed_password != "":
            self.logger.warning("BackendServer: Both 'password' and 'hashed_password' given. Ignoring 'password' and using 'hashed_password'!")
            self._password = None

        if self._password is not None and self._password != "" and (self._hashed_password is None or self._hashed_password == ""):
            self.logger.warning("BackendServer: Giving plaintext password in configuration is insecure. Consider using 'hashed_password' instead!")
            self._hashed_password = None

        if (self._password is not None and self._password != "") or (self._hashed_password is not None and self._hashed_password != ""):
            self._basic_auth = True
        else:
            self._basic_auth = False
        self._sh = sh

        if self.is_int(port):
            self.port = int(port)
        else:
            self.port = 8383
            if port is not None:
                self.logger.error("BackendServer: Invalid value '"+str(port)+"' configured for attribute 'port' in plugin.conf, using '"+str(self.port)+"' instead")

        if self.is_int(threads):
            self.threads = int(threads)
        else:
            self.threads = 8
            self.logger.error("BackendServer: Invalid value '"+str(threads)+"' configured for attribute 'thread' in plugin.conf, using '"+str(self.threads)+"' instead")

        if ip == '':
            ip = self.get_local_ip_address()
            self.logger.debug("BackendServer: Using local ip address '{0}'".format(ip))
        else:
            pass
        #    if not self.is_ip(ip):
        #         self.logger.error("BackendServer: Invalid value '"+str(ip)+"' configured for attribute ip in plugin.conf, using '"+str('0.0.0.0')+"' instead")
        #         ip = '0.0.0.0'
        language = language.lower()
        if language != '':
            if not load_translation(language):
                self.logger.warning("BackendServer: Language '{0}' not found, using standard language instead".format(language))
        self.developer_mode =  self.my_to_bool(developer_mode, 'developer_mode', False)

        self.updates_allowed = self.my_to_bool(updates_allowed, 'updates_allowed', True)

        if self.is_int(pypi_timeout):
            self.pypi_timeout = int(pypi_timeout)
        else:
            self.pypi_timeout = 5
            if pypi_timeout is not None:
                self.logger.error("BackendServer: Invalid value '" + str(pypi_timeout) + "' configured for attribute 'pypi_timeout' in plugin.conf, using '" + str(self.pypi_timeout) + "' instead")

        current_dir = os.path.dirname(os.path.abspath(__file__))
        self.logger.debug("BackendServer running from '{}'".format(current_dir))

        config = {'global': {
            'engine.autoreload.on': False,
            'tools.staticdir.debug': True,
            'tools.trailing_slash.on': False
            },
            '/': {
                'tools.auth_basic.on': self._basic_auth,
                'tools.auth_basic.realm': 'earth',
                'tools.auth_basic.checkpassword': self.validate_password,
                'tools.staticdir.root': current_dir,
            },
            '/static': {
                'tools.staticdir.on': True,
                'tools.staticdir.dir': os.path.join(current_dir, 'static')
            }
        }
        from cherrypy._cpserver import Server
        self._server = Server()
        self._server.socket_host = ip
        self._server.socket_port = int(self.port)
        self._server.thread_pool = self.threads
        self._server.subscribe()

        self._cherrypy = cherrypy
        self._cherrypy.config.update(config)
        self._cherrypy.tree.mount(Backend(self, self.updates_allowed, language, self.developer_mode, self.pypi_timeout), '/', config = config)

    def run(self):
        self.logger.debug("BackendServer: rest run")
        self._server.start()
        #self._cherrypy.engine.start()
        self.logger.debug("BackendServer: engine started")
        #cherrypy.engine.block()
        self.alive = True

    def stop(self):
        self.logger.debug("BackendServer: shutting down")
        self._server.stop()
        #self._cherrypy.engine.exit()
        self.logger.debug("BackendServer: engine exited")
        self.alive = False

    def parse_item(self, item):
        pass

    def parse_logic(self, logic):
        pass

    def update_item(self, item, caller=None, source=None, dest=None):
        pass

    def validate_password(self, realm, username, password):
        if username != self._user or password is None or password == "":
            return False

        if self._hashed_password is not None:
            return Utils.check_hashed_password(password, self._hashed_password)
        elif self._password is not None:
            return password == self._password

        return False
예제 #9
0
import cherrypy
from cherrypy._cpserver import Server

import endpoints

#* Server Setup
cherrypy.server.unsubscribe()

dispatchServer = Server()
dispatchServer.socket_port = 4000
dispatchServer.subscribe()

if __name__ == "__main__":
    endpoints.init()
    cherrypy.engine.start()
    cherrypy.engine.block()
    
예제 #10
0
        return "OK"

    parts = path.split("/")
    assert parts[0] == ""
    assert parts[1] == ".well-known"
    assert parts[2] == "acme-challenge"
    token = parts[3]

    start_response("200 OK", [])
    return tokens.get(token, "")


from cherrypy._cpserver import Server

cherrypy.server.unsubscribe(
)  # don't start default http server that listens on some socket
cherrypy.config.update({"/": {}})

server = Server(exos_vr="ALL")
server._socket_host = "::"
server.socket_port = 80

server.thread_pool = 7
server.subscribe()

cherrypy.tree.graft(httpd_service, "/")

cherrypy.engine.start()
server.start()
cherrypy.engine.block()
예제 #11
0
class PhoneHomeServer(object):
    def __init__(self, source_plugin, plugin_cfg):
        self.logger = c.logger
        self._phs_server = Server()
        self._phs_server.socket_host = c.conf.SERVICES.Phs.ServiceBindAddress
        self._phs_server.socket_port = c.conf.SERVICES.Phs.ServiceListenPort
        self.device_type = None
        self.service_chain = None
        self.deviceIP = None
        self.sn_nr = None

        if c.conf.SERVICES.Phs.EnableSSL:

            self.logger.info(
                Tools.create_log_msg(logmsg.PHS_SERVICE, None,
                                     logmsg.PHS_SSL_ENABLED))
            self._phs_server.ssl_module = 'builtin'

            if os.path.isfile(c.conf.SERVICES.Phs.SSLCertificate):
                self._phs_server.ssl_certificate = c.conf.SERVICES.Phs.SSLCertificate

            else:
                self.logger.info(
                    Tools.create_log_msg(logmsg.PHS_SERVICE, None,
                                         logmsg.PHS_SSL_NO_CERT))

            if os.path.isfile(c.conf.SERVICES.Phs.SSLPrivateKey):
                self._phs_server.ssl_private_key = c.conf.SERVICES.Phs.SSLPrivateKey
            else:
                self.logger.info(
                    Tools.create_log_msg(logmsg.PHS_SERVICE, None,
                                         logmsg.PHS_SSL_NO_KEY))

        self._phs_server.subscribe()
        self._source_plugin = source_plugin
        self._plugin_cfg = plugin_cfg
        self.logger.info(
            Tools.create_log_msg(
                logmsg.PHS_SERVICE, None,
                logmsg.PHS_LISTEN.format(self._phs_server.socket_host,
                                         self._phs_server.socket_port)))

    @cherrypy.expose
    def init(self, **params):

        self.deviceIP = cherrypy.request.headers['Remote-Addr']
        self.sn_nr = params['uid']
        status, data = Tools.get_config(
            lookup_type=c.CONFIG_LOOKUP_TYPE_GET_DEVICE_CFG,
            serialnumber=self.sn_nr,
            deviceOsshId=None)

        if status:

            try:

                self.device_type = data['yapt']['device_type']
                self.service_chain = data['yapt']['service_chain']

            except KeyError as ke:
                self.logger.info('{0} {1}'.format(
                    logmsg.PHS_SERVICE + ':',
                    logmsg.PHS_CONF_KEY_ERROR.format(ke.message)))
                return

            _boostrap_init_file = c.conf.SERVICES.Phs.InitConfPath + self.device_type + '.xml'

            if os.path.isfile(_boostrap_init_file):
                response = None

                try:
                    env = Environment(autoescape=select_autoescape(['xml']),
                                      loader=FileSystemLoader(
                                          c.conf.SERVICES.Phs.InitConfPath),
                                      trim_blocks=True,
                                      lstrip_blocks=True)
                    response = env.get_template(self.device_type +
                                                '.xml').render(
                                                    serial=self.sn_nr)

                except (TemplateNotFound, IOError) as err:
                    self.logger.info(
                        Tools.create_log_msg(
                            logmsg.PHS_SERVICE, self.sn_nr,
                            logmsg.PHS_TEMPLATE_ERROR.format(
                                err.errno, err.strerror, err.filename)))
                return response

            else:
                self.logger.info(
                    Tools.create_log_msg(
                        logmsg.PHS_SERVICE, self.sn_nr,
                        logmsg.PHS_BOOSTRAP_FILE_FAILED.format(
                            _boostrap_init_file)))

        else:
            self.logger.info(
                Tools.create_log_msg(logmsg.PHS_SERVICE, self.sn_nr,
                                     logmsg.PHS_DEV_CONF_FAILED))

    @cherrypy.expose
    def activation(self, **params):
        pass

    @cherrypy.expose
    def notification(self, **params):

        cherrypy.response.status = 201
        body = cherrypy.request.body.read()
        xml_body = etree.fromstring(body)
        ns_orig = 'http://juniper.net/zerotouch-bootstrap-server'

        for item in xml_body.iter('{' + ns_orig + '}notification-type'):

            if item.text == c.PHS_NOTIFICATION_CONF_APPLIED:
                self.logger.info(
                    Tools.create_log_msg(logmsg.PHS_SERVICE, self.sn_nr,
                                         logmsg.PHS_STAGE1_SUCCESS).format(
                                             params['uid']))

            elif item.text == c.PHS_NOTIFICATION_CONF_FAILED:
                self.logger.info(
                    Tools.create_log_msg(
                        logmsg.PHS_SERVICE, self.sn_nr,
                        logmsg.PHS_STAGE1_FAILED.format(params['uid'])))

            elif item.text == c.PHS_NOTIFICATION_BOOTSTRAP_COMPLETED:
                self.logger.info(
                    Tools.create_log_msg(
                        logmsg.PHS_SERVICE, self.sn_nr,
                        logmsg.PHS_BOOTSTRAP_SUCCESS.format(params['uid'])))

                if c.SERVICEPLUGIN_OSSH in self.service_chain:
                    self.logger.info(
                        Tools.create_log_msg(
                            logmsg.PHS_SERVICE, self.sn_nr,
                            logmsg.PHS_SEC_SVC.format(c.SERVICEPLUGIN_OSSH,
                                                      c.SERVICEPLUGIN_OSSH)))
                    return

                else:
                    sample_device = self._source_plugin.run_normalizer(
                        datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                        device=self.deviceIP)

                    # NFX JDM facts return empty serial number so we have to add it here
                    if self.device_type == 'nfx':
                        sample_device.deviceSerial = self.sn_nr

                    message = AMQPMessage(
                        message_type=c.AMQP_MSG_TYPE_DEVICE_ADD,
                        payload=sample_device,
                        source=c.AMQP_PROCESSOR_SVC)
                    self._source_plugin.send_message(message=message)

            elif item.text == c.PHS_NOTIFICATION_BOOTSTRAP_FAILED:
                self.logger.info(
                    Tools.create_log_msg(
                        logmsg.PHS_SERVICE, self.sn_nr,
                        logmsg.PHS_BOOSTRAP_FAILED.format(params['uid'])))