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 setup(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)
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 = 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
# 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 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
hdr = 'Access-Control-Allow-%s'
#
# 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 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, " \
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
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")
},
'apscheduler.job_defaults.coalesce': 'true',
'apscheduler.job_defaults.max_instances': '1',
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 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):
gapi1 = XMLRPCHandler('gapi1')
gapi1.connect(app, '/foam/gapi/1')
gapi1.register_instance(AMAPIv1(app.logger))
app.logger.info("[GAPIv1] Loaded.")
return gapi1
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"]
# 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')
import cgi
from flask import Flask, request
from flaskext.xmlrpc import XMLRPCHandler, Fault
app = Flask(__name__)
handler = XMLRPCHandler('api')
handler.connect(app, '/RPC2')
@app.before_request
def log_request_info():
app.logger.info('Headers: %s', request.headers)
app.logger.info('Body: %s', request.get_data())
pass
@handler.register_function('purenetwork.list')
def pure_network_list(*args, **kwargs):
return []
@handler.register_function('purearray.list')
def pure_array_list(*args, **kwargs):
return [{
'array_name': 'trashy',
'management_address': 'localhost',
'revision': '201909102318+ed5f1a6',
'version': '99.9.9',
'id': '84de4d02-f435-497f-9b9c-b1a33f16b991'
}]
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()
return k.get_build(nvr)
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
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()
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):
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:
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
