def setup (app): legexpapi = XMLRPCHandler('legacyexpedientapi') legexpapi.connect(app, '/core/legacyexpedientapi/xmlrpc/') #legexpapi = AMLegExpAPI(app) legexpapi.register_instance(AMLegExpAPI(app.logger)) app.logger.info("[LegacyExpedientAPI] Loaded.") return legexpapi
def registerXMLRPC(self, unique_service_name, instance, endpoint): """Register the receiver. {unique_service_name} just has to be a unique name (dont ask why). The {instance} is an object (an {Dispatcher} instance) providing the methods which get called via the XMLRPC enpoint. {endpoint} is the mounting point for the XML RPC interface (e.g. '/geni' ).""" handler = XMLRPCHandler(unique_service_name) handler.connect(self._flaskapp.app, endpoint) handler.register_instance(instance)
def setup(app): handler = XMLRPCHandler('XMLRPC') handler.connect(app, '/RPC2') handler.connect(app, '/XMLRPC') handler.register_instance(NipapXMLRPC()) return app
def setup(): app = Flask('nipap.xmlrpc') Compress(app) handler = XMLRPCHandler('XMLRPC') handler.connect(app, '/RPC2') handler.connect(app, '/XMLRPC') handler.register_instance(NipapXMLRPC()) return app
def setup(app): legexpapi = XMLRPCHandler('legacyexpedientapi') legexpapi.connect(app, '/core/legacyexpedientapi/xmlrpc/') #legexpapi = AMLegExpAPI(app) legexpapi.register_instance(AMLegExpAPI(app.logger)) app.logger.info("[LegacyExpedientAPI] Loaded.") return legexpapi
from flask import Flask from flaskext.xmlrpc import XMLRPCHandler, Fault app = Flask(__name__) handler = XMLRPCHandler('api') handler.connect(app, '/api') @handler.register def operator(x)): x= input("Enter a number to square:") if x == Null: raise Fault("please input a number") return x^2 app.run()
from flaskext.xmlrpc import XMLRPCHandler, Fault from product_listings_manager import products, utils handler = XMLRPCHandler('xmlrpc') @handler.register def getProductInfo(*a, **kw): try: return products.getProductInfo(*a, **kw) except Exception: utils.log_remote_call_error('XMLRPC call getProductInfo() failed', *a, **kw) raise Fault(1, 'An unexpected error has occurred.') @handler.register def getProductListings(*a, **kw): try: return products.getProductListings(*a, **kw) except Exception: utils.log_remote_call_error('XMLRPC call getProductListings() failed', *a, **kw) raise Fault(1, 'An unexpected error has occurred.')
from soaplib.core.model.primitive import Decimal from soaplib.core.server import wsgi from example_server import app functions = { 'add': lambda a, b: a + b, 'subtract': lambda a, b: a - b, 'multiply': lambda a, b: a * b, 'divide': lambda a, b: a / b, 'square': lambda a: a * a, 'squareRoot': lambda a: math.sqrt(a), 'sum': lambda a: sum(a), 'average': lambda a: sum(a) / len(a), } xmlrpc_handler = XMLRPCHandler('xml-rpc') xmlrpc_handler.connect(app, '/xml-rpc') for name, func in functions.iteritems(): xmlrpc_handler.register(func, name) class JSONRPCHandler(simplejsonrpc.JsonrpcHandler): def dispatch(self, method_name): return functions.get(method_name, None); @app.route("/json-rpc", methods=['GET', 'POST', 'OPTIONS']) def jsonrpc(): result = '' if request.headers["CONTENT_LENGTH"]: handler = JSONRPCHandler() result = handler.handle(request.data) response = make_response(result, 200) # add CORS headers
from flask import g from flaskext.xmlrpc import XMLRPCHandler, Fault from flog import app from flog.helpers import verify_user from pymongo import ASCENDING, DESCENDING # MetaWeblogAPI XML-RPC handler = XMLRPCHandler('api') handler.connect(app, '/api') metaweblog = handler.namespace('metaWeblog') blogger = handler.namespace('blogger') @metaweblog.register def newPost(blogid, username, password, content, publish): if not verify_user(username, password): raise Fault("invalid_user", "Invalid username/password, please " \ "try again.") post = g.conn.flog.blog.BlogPost() post['title'] = unicode(content['title']) post['body'] = unicode(content['description']) if 'categories' in content.keys(): post['tags'] = content['categories'] post.save() return post['slug'] @metaweblog.register def editPost(postid, username, password, content, publish): if not verify_user(username, password): raise Fault("invalid_user", "Invalid username/password, " \
# Authors: # Michael DeHaan <michael.dehaan AT gmail> # Tim Flink <*****@*****.**> from flask import Blueprint, send_from_directory from remote_install import app from flaskext.xmlrpc import XMLRPCHandler import base64 import string import os import stat import fcntl import errno handler = XMLRPCHandler('anamon') handler.connect(app, '/anamon') anamon = Blueprint('anamon', __name__) @anamon.route('/aux/anamon', methods = ['GET']) def get_anamon(): return send_from_directory(os.path.join(app.root_path, 'static'), 'aux/anamon', mimetype='application/octet-stream') @anamon.route('/aux/anamon.init', methods = ['GET']) def get_anamon_init(): return send_from_directory(os.path.join(app.root_path, 'static'), 'aux/anamon.init', mimetype='application/octet-stream')
def test_register(self): handler = XMLRPCHandler('api')
import datetime import sys import os, errno from flask import Flask, request, session, g, redirect, url_for, \ abort, render_template, flash, escape from flaskext.xmlrpc import XMLRPCHandler, Fault import messager app = Flask(__name__) app.config.from_object(__name__) handler = XMLRPCHandler('api') handler.connect(app, '/xr') archive_path = "./raw_archive/" @app.route("/") def index(): return "hai" @handler.register def hello(name): if not name: raise Fault("unknown_recipient", "I need someone to greet!") return "Hello, %s!" % name def get_real_nick(long_nick): sep = long_nick.find("!") nick = long_nick[:sep] return nick
def setup(app): gapi2 = XMLRPCHandler('gapi2') gapi2.connect(app, '/foam/gapi/2') gapi2.register_instance(AMAPIv2(app.logger)) app.logger.info("[GAPIv2] Loaded.") return gapi2
# configuration DATABASE = '/tmp/boji.db' DEBUG = True SECRET_KEY = 'test key' NUM_PAGE = 20 default_response = util.make_default_update() koji_getbuild_resp = {'owner_name': 'cebbert', 'package_name': 'kernel', 'task_id': 3085371, 'creation_event_id': 3729725, 'creation_time': '2011-05-21 17:16:58.584573', 'epoch': None, 'nvr': 'kernel-2.6.35.13-92.fc14', 'name': 'kernel', 'completion_time': '2011-05-21 18:37:45.561815', 'state': 1, 'version': '2.6.35.13', 'release': '92.fc14', 'creation_ts': 1305998218.58457, 'package_id': 8, 'id': 244715, 'completion_ts': 1306003065.56182, 'owner_id': 417} app = Flask(__name__) #app.debug = True app.config.from_object(__name__) init_db() handler = XMLRPCHandler('mockkoji') handler.connect(app, '/mockkoji') @app.teardown_request def shutdown_session(exception=None): db_session.remove() def get_bodhi_connection(): return fedora.client.bodhi.BodhiClient() @handler.register def getBuild(nvr): if nvr is None: raise Fault("no_build", "there has to be some build passed in!") k = mock_koji.MockKoji()
import tools import sys from flask import Flask, session, render_template from flaskext.xmlrpc import XMLRPCHandler, Fault from pymongo import MongoClient from models import * config = configparser.ConfigParser() config.read('config-test.ini') logging.basicConfig(level=logging.DEBUG) logger = logging.getLogger(__name__) app = Flask(__name__) handler = XMLRPCHandler('api') handler.connect(app, '/api') client = MongoClient(tools.composeDB(config['Database'])) db = client[config['Database']['DB_NAME']] """ USERS """ @handler.register def login(username, password): logger.info('Login attempt by %s', username) res = User.login(db, username, password) if not res:
# -*- coding: utf8 -*- __all__ = ('CIAHook', ) import xmltodict from flask import url_for, request, abort import flask_wtf as wtf # Continue using old flask ext naming convention for XML-RPC # since XML-RPC doesn't support new one from flaskext.xmlrpc import XMLRPCHandler from notifico import db from notifico.services.hooks import HookService handler = XMLRPCHandler('hub') hub = handler.namespace('hub') class CIAConfigForm(wtf.Form): use_colors = wtf.BooleanField( 'Use Colors', validators=[wtf.Optional()], default=True, description=('If checked, messages will include minor mIRC coloring.')) class CIAHook(HookService): """ HookService hook for cia.vc style messages. """ SERVICE_NAME = 'cia.vc' SERVICE_ID = 50
# # Any Red Hat trademarks that are incorporated in the source # code or documentation are not subject to the GNU General Public # License and may only be used or replicated with the express permission # of Red Hat, Inc. # ''' MirrorManager2 xmlrpc controller. ''' import base64 import flask from flaskext.xmlrpc import XMLRPCHandler, Fault from mirrormanager2 import APP, ADMIN, SESSION from mirrormanager2.lib import model XMLRPC = XMLRPCHandler('xmlrpc') XMLRPC.connect(APP, '/xmlrpc') @XMLRPC.register def checkin(pickledata): config = pickle.loads(bz2.decompress(base64.urlsafe_b64decode(p))) r, message = read_host_config(SESSION, config) if r is not None: return message + 'checked in successful' else: return message + 'error checking in'
from customer import Customer, CustomerTag, CustomerTagCustomerRel from order import Order, OrderProduct from invoice import Invoice from commercial import Commercial from product import Product, ProductCategory, ProductTag, ProductTagProductRel from rma import RmaStatus, RmaStage, Rma, RmaProduct from auth import auth from sync_log import SyncLog from flask import session from utils import parse_many2one_vals import xmlrpclib import datetime import logging from implemented_models import MODELS_CLASS handler = XMLRPCHandler('xmlrpc') handler.connect(app, '/xmlrpc') @handler.register def login(username, password): if not username or not password: raise Fault("unknown_data", "Username and password are required!") user = auth.authenticate(username, password) if not user: raise Fault("invalid_user", "Invalid username/password, please try again.") else: auth.login_user(user) return session["user_pk"]
from flaskext.xmlrpc import XMLRPCHandler, Fault rpc_handler = XMLRPCHandler('api') from models import DataSensors, DataCollector, db import datetime @rpc_handler.register def add_data(host_name, date_statement, sensor_value, sensor_type="TEMPERATURE"): date_statement = datetime.datetime.strptime(date_statement, '%Y-%m-%dT%H:%M:%S.%f') dc = DataCollector.query.filter( DataCollector.host_name == host_name).first() if not dc: dc = DataCollector(host_name, "DISABLE", "-10", "-20", "") s = DataSensors(date_statement, sensor_value, sensor_type) #dc.data.all() dc.data.append(s) #dc.data.add(s) db.session.merge(dc) db.session.commit() #db.session.flush() dc.update_state() #raise Fault("Mon exception", "I need someone to greeti %s!" % # (type(Fault))) return "Data added in %s!" % dc.host_name
def setup (app): gapi1 = XMLRPCHandler('gapi1') gapi1.connect(app, '/foam/gapi/1') gapi1.register_instance(AMAPIv1(app.logger)) app.logger.info("[GAPIv1] Loaded.") return gapi1
# License and may only be used or replicated with the express permission # of Red Hat, Inc. # ''' MirrorManager2 xmlrpc controller. ''' import base64 import flask from flaskext.xmlrpc import XMLRPCHandler, Fault from mirrormanager2.app import APP, ADMIN, SESSION from mirrormanager2.lib import model #from mirrormanager2.lib.hostconfig import read_host_config XMLRPC = XMLRPCHandler('xmlrpc') XMLRPC.connect(APP, '/xmlrpc') @XMLRPC.register def checkin(pickledata): config = pickle.loads(bz2.decompress(base64.urlsafe_b64decode(p))) r, message = read_host_config(SESSION, config) if r is not None: return message + 'checked in successful' else: return message + 'error checking in'
from flaskext.xmlrpc import XMLRPCHandler, Fault from app import app from database import db from user import User from customer import Customer from product import Product from auth import auth from flask import session handler = XMLRPCHandler('xmlrpc') handler.connect(app, '/xmlrpc') @handler.register def login(username, password): if not username or not password: raise Fault("unknown_data", "Username and password are required!") user = auth.authenticate(username, password) if not user: raise Fault("invalid_user", "Invalid username/password, please try again.") else: auth.login_user(user) return session["user_pk"] def _check_user(user_id, password): user = User.get(User.id==user_id) if not user or not user.check_password(password): raise Fault("invalid_user", "Invalid username/password, please try again.") return True
def setup(app): sfa_api = XMLRPCHandler("sfaapi") sfa_api.connect(app, "/sfa/2/") sfa_api.register_instance(SfaApi(app.logger)) app.logger.info("[SfaApi] Loaded.") return sfa_api
def setup(app): sfa_api = XMLRPCHandler('sfaapi') sfa_api.connect(app, '/sfa/2/') sfa_api.register_instance(SfaApi(app.logger)) app.logger.info("[SfaApi] Loaded.") return sfa_api
_log_file = os.path.join(coreapp.config.get("LOG_PATH"),"flask.log") flask_app.logger.addHandler(logging.FileHandler(_log_file)) for _config in ["LOG_PATH","DATA_PATH","PROJECT_PATH","HISTORY_PATH"]: flask_app.config[_config] = coreapp.config[_config] flask_app.config["coreapp"] = coreapp flask_app.config["scheduler"] = coreapp.scheduler #flask_app.config["db_session"] = coreapp.config.get("db_session") from .proxy import SchedulerProxy _handler = XMLRPCHandler('api') _scheduler_proxy = SchedulerProxy(flask_app) _handler.register_instance(_scheduler_proxy) _handler.connect(flask_app, '/api') flask_app.config["scheduler_proxy"] = _scheduler_proxy from apscheduler.schedulers.tornado import TornadoScheduler import os # The "apscheduler." prefix is hard coded apscheduler = TornadoScheduler({ 'apscheduler.jobstores.default': { 'type': 'sqlalchemy', 'url': 'sqlite:///'+os.path.join(flask_app.config["DATA_PATH"],"apscheduler.db") },
MASTERINTERFACE_VALIDATE_TKT_SERVICE="https://portal.vph-share.eu/validatetkt/?ticket=%s", PERMANENT_SESSION_LIFETIME = timedelta(seconds=TIMEOUT) ) #TICKET = Ticket(app.config['SECRET_KEY']) # flask LoginMagers login_manager = LoginManager() login_manager.setup_app(app) login_manager.login_view = "login" ############################################################ ############################################################################ # connect xmlrpc handler to app handler = XMLRPCHandler('api') handler.connect(app, '/api') @login_manager.user_loader def load_user(id): """ *load_user* method This method should take the unicode ID of a user and return the corresponding user object. """ return USERS.get(int(id)) @app.route("/")
# -*- coding: utf8 -*- __all__ = ('CIAHook',) import xmltodict from flask import url_for, request, abort import flask_wtf as wtf # Continue using old flask ext naming convention for XML-RPC # since XML-RPC doesn't support new one from flaskext.xmlrpc import XMLRPCHandler from notifico import db from notifico.services.hooks import HookService handler = XMLRPCHandler('hub') hub = handler.namespace('hub') class CIAConfigForm(wtf.Form): use_colors = wtf.BooleanField('Use Colors', validators=[ wtf.Optional() ], default=True, description=( 'If checked, messages will include minor mIRC coloring.' )) class CIAHook(HookService): """ HookService hook for cia.vc style messages. """ SERVICE_NAME = 'cia.vc'
def setup (app): gapi2 = XMLRPCHandler('gapi2') gapi2.connect(app, '/foam/gapi/2') gapi2.register_instance(AMAPIv2(app.logger)) app.logger.info("[GAPIv2] Loaded.") return gapi2
# -*- coding: utf-8 -*- """ http://xmlrpc.scripting.com/metaWeblogApi.html This is the metaWeblog API to marked """ from flask import Blueprint, url_for from flaskext.xmlrpc import XMLRPCHandler, Fault from marked.models import Post, Page, Category # TODO: NO sqlalchemy outside of models from sqlalchemy.exc import IntegrityError metaweblog = Blueprint('metaweblog', __name__) handler = XMLRPCHandler('api') handler.connect(metaweblog, '/xml/rpc') mwl = handler.namespace('metaWeblog') blogger = handler.namespace('blogger') @mwl.register def newPost(blog_id, username, password, struct, publish): """docstring for newPost""" print '---\nrunning metaWeblog.newPost' if blog_id == 'Static': page = Page(title=struct['title'], content=struct['description'], draft=not publish) page.slug = struct['link'] else: page = Post(title=struct['title'], content=struct['description'], draft=not publish) if 'categories' in struct:
from flask import Flask from flaskext.xmlrpc import XMLRPCHandler, Fault from workflow.interpreter import Evaluator app = Flask(__name__) handler = XMLRPCHandler('api') handler.connect(app, '/') def cb(value): print 'COMPLETE: %s'%value e = Evaluator('any(add(1, 3), add(4, 5))', cb) @handler.register def defer_return(id, value): e.defer_return(id, value) e() app.run()