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 = 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
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)
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()
