def configure(config_files):
group = cfg.OptGroup(name='test', title='group for test')
args = None
CONF(args=args, project=group.name, default_config_files=config_files)
CONF.register_group(group)
logging.setup(CONF, group.name)
defalut_logging.captureWarnings(True)
def list_agent_opts():
from gogamechen2 import common
group = cfg.OptGroup(common.NAME)
CONF = cfg.CONF
CONF.register_group(group)
from goperation.manager.rpc.agent.config import rpc_endpoint_opts
cfg.set_defaults(rpc_endpoint_opts, module='gogamechen2.api.rpc')
return rpc_endpoint_opts
def list_agent_opts():
from gopdb import common
group = cfg.OptGroup(common.DB)
CONF = cfg.CONF
CONF.register_group(group)
from goperation.manager.rpc.agent.config import rpc_endpoint_opts
from gopdb.api.rpc.impl.config import db_opts
from gopdb.api.rpc.impl.mysql.config import mysql_db_opts
cfg.set_defaults(rpc_endpoint_opts, module='gopdb.api.rpc')
return rpc_endpoint_opts + db_opts + mysql_db_opts
def configure(name, config_files, config_dirs=None):
group = cfg.OptGroup(name=name, title='group of goperation %s' % name)
args = None
if config_dirs is not None:
args = []
if isinstance(config_dirs, basestring):
config_dirs = [
config_dirs,
]
for _dir in config_dirs:
args.extend(['--config-dir', _dir])
if isinstance(config_files, basestring):
config_files = [
config_files,
]
# set default of goperation
set_all_default()
service_config.set_default_for_default_log_levels([])
# call cli opts before CONF init
service_config.cliopts()
CONF(args=args, project=group.name, default_config_files=config_files)
CONF.register_group(group)
# set base config
service_config.configure()
# reg base opts
CONF.register_opts(service_base_opts)
# set log config
logging.setup(CONF, group.name)
default_logging.captureWarnings(True)
if systemutils.LINUX:
if not CONF.repo:
raise RuntimeError('rpm repo is not set')
repofile = '/etc/yum.repos.d/goputil.repo'
cf = ConfigParser.ConfigParser()
if not os.path.exists(repofile):
cf.add_section('goputil')
cf.set('goputil', 'name', 'Goperation util rpm source')
cf.set('goputil', 'baseurl', CONF.repo)
cf.set('goputil', 'enabled', '1')
cf.set('goputil', 'gpgcheck', '0')
with open(repofile, 'wb') as f:
cf.write(f)
else:
cf.read(repofile)
if cf.get('goputil', 'baseurl') != CONF.repo:
cf.set('goputil', 'baseurl', CONF.repo)
with open(repofile, 'wb') as f:
cf.write(f)
return group
# regex=REGEXPASS,
secret=True,
help='logdb db rw user passwd'),
cfg.StrOpt(
'logdb_ro_user',
# regex=REGEXUSER,
help='logdb db ro user name'),
cfg.StrOpt(
'logdb_ro_passwd',
# regex=REGEXPASS,
secret=True,
help='logdb db ro user passwd'),
]
gameserver_group = cfg.OptGroup(name='%s.%s' %
(common.NAME, common.GAMESERVER),
title='gameserver group')
gmserver_group = cfg.OptGroup(name='%s.%s' % (common.NAME, common.GMSERVER),
title='gm server group')
crossserver_group = cfg.OptGroup(name='%s.%s' %
(common.NAME, common.CROSSSERVER),
title='cross server group')
def list_game_opts():
_sources_opts = copy.deepcopy(sources_opts)
_datadb_opts = copy.deepcopy(datadb_opts)
_logdb_opts = copy.deepcopy(logdb_opts)
cfg.set_defaults(_datadb_opts,
datadb_user='******',
datadb_ro_user='******')
def __init__(self):
super(RpcAgentManager, self).__init__(target=target_server(self.agent_type, CONF.host, fanout=True))
interface, self.ipnetwork = get_network(self.local_ip)
if not self.ipnetwork:
raise RuntimeError('can not find local ip netmask')
LOG.debug('Local ip %s/%s on interface %s' % (self.local_ip, self.ipnetwork.netmask, interface))
global DISK
DISK = psutil.disk_usage(self.work_path).total/(1024*1024)
# agent id
self._agent_id = None
# port and port and disk space info
conf = CONF[manager_common.AGENT]
self.conf = conf
self.ports_range = validators['type:ports_range_list'](conf.ports_range) if conf.ports_range else []
# zone mark
self.zone = conf.zone
self.dnsnames = conf.dnsnames
# key: port, value endpoint name
self.allocked_ports = {}
# left ports
self.left_ports = set()
for p_range in self.ports_range:
down, up = map(int, p_range.split('-'))
if down < 1024:
raise ValueError('Port 1-1024 is not allowed')
for port in range(down, up):
self.left_ports.add(port)
# init metadata
self._metadata = super(RpcAgentManager, self).metadata
self._metadata.setdefault('agent_type', self.agent_type)
self._metadata.setdefault('zone', self.zone)
self._metadata.setdefault('dnsnames', conf.dnsnames)
# init httpclient
self.client = AgentManagerClient(httpclient=get_http())
# init filemanager
self.filemanager = FileManager(conf=conf,
threadpool=threadpool,
infoget=lambda x: self.client.file_show(x)['data'][0])
# init endpoint
if conf.endpoints:
# endpoint class must be singleton
for endpoint in conf.endpoints:
endpoint_group = cfg.OptGroup(endpoint.lower(),
title='endpopint of %s' % endpoint)
CONF.register_group(endpoint_group)
CONF.register_opts(rpc_endpoint_opts, endpoint_group)
endpoint_class = '%s.%s' % (CONF[endpoint_group.name].module,
self.agent_type.capitalize())
try:
cls = importutils.import_class(endpoint_class)
except Exception:
LOG.error('Import class %s of %s fail' % (endpoint_class, endpoint_group.name))
raise
else:
obj = cls(manager=self)
if not isinstance(obj, RpcAgentEndpointBase):
raise TypeError('Endpoint string %s not base from RpcEndpointBase')
self.endpoints.add(obj)
self.endpoint_lock = lockutils.Semaphores()
self.websockets = dict()
self.reporter = OnlinTaskReporter(self)
group_id = 97
platform = 'ios'
a = 'C:\\Users\\loliz_000\\Desktop\\etc\\goperation\\goperation.conf'
b = 'C:\\Users\\loliz_000\\Desktop\\etc\\goperation\\gcenter.conf'
c = 'C:\\Users\\loliz_000\\Desktop\\etc\\goperation\\endpoints\gogamechen3.server.conf'
from goperation.manager import common as manager_common
from goperation import config as goperation_config
# create a new project and group named gcenter
name = manager_common.SERVER
# init goperation config
main_group = goperation_config.configure(name, [a, b, c])
from simpleservice.ormdb.config import database_opts
endpoint_group = cfg.OptGroup(common.NAME,
title='endpopint of %s' % common.NAME)
CONF.register_group(endpoint_group)
CONF.register_opts(database_opts, endpoint_group)
session = endpoint_session(readonly=True)
query = session.query(func.max(GameArea.show_id)).select_from(AppEntity)
query = query.join(AppEntity.areas, isouter=True)
query = query.filter(
and_(AppEntity.group_id == group_id, AppEntity.platform == platform))
last_show_id = query.scalar() or 0
print last_show_id
from simpleutil.config import cfg
from simpleutil.config.cfg import types
from goperation.config import endpoint_load_opts
from goperation.manager import common as manager_common
from goperation.filemanager.config import filemanager_opts
CONF = cfg.CONF
agent_group = cfg.OptGroup(name=manager_common.AGENT,
title='Agent base options group')
CONF.register_group(agent_group)
rpc_agent_opts = [
cfg.StrOpt('zone',
default='all',
regex='^[a-z][a-z0-9]+$',
help='Agent zone mark'),
cfg.IntOpt('websokcets',
default=5,
min=0,
max=10,
help='websocket sub process number'),
cfg.ListOpt(
'dnsnames',
item_type=types.Hostname(),
default=[],
help='Agent dns hostnames',
),
cfg.MultiOpt('ports_range',
item_type=cfg.types.PortRange(),
import os
from goperation.manager.rpc.agent.application.taskflow import application
from goperation.manager.rpc.agent.application.taskflow import middleware
from goperation.manager.rpc.agent.application.taskflow import database
from goperation.manager.rpc.agent.application.taskflow import pipe
from simpleflow.utils.storage_utils import build_session
from simpleservice.ormdb.argformater import connformater
from simpleflow import api
from simpleflow.storage import Connection
from simpleflow.engines.engine import ParallelActionEngine
from simpleutil.config import cfg
from goperation.manager.rpc.agent.application.base import AppEndpointBase
test_group = cfg.OptGroup('testopt')
class TestFileManager():
"""测试用 file manager"""
def __init__(self, update_base):
self.update_base = update_base
def get(self, target, download=True, timeout=None):
for name in os.listdir(self.update_base):
if name.startswith(target.source):
target.realpath = os.path.join(self.update_base, name)
return os.path.join(self.update_base, name)
raise RuntimeError('No file found')
from simpleutil.config import cfg
from fluttercomic import common
from fluttercomic.plugin.platforms import config
CONF = cfg.CONF
NAME = 'ipay'
group = cfg.OptGroup(name='%s.%s' % (common.NAME, NAME),
title='Fluttercomic Pay platform ipay')
ipay_opts = [
cfg.StrOpt('appId', help='ipay appId'),
cfg.StrOpt('appUid', help='ipay app userid'),
cfg.IntOpt('waresId', help='ipay waresId'),
cfg.StrOpt('signtype',
default='RSA',
choices=['RSA'],
help='ipay signtype appId'),
cfg.StrOpt('rsa_private',
default='/etc/goperation/endpoints/platforms/ipay_private.key',
help='ipay signtype rsa private key file'),
cfg.StrOpt('rsa_public',
default='/etc/goperation/endpoints/platforms/ipay_public.key',
help='ipay signtype rsa public key file'),
cfg.BoolOpt('h5', default=False, help='ipay signtype use h5 api'),
cfg.UrlOpt('url_r', help='ipay pay with h5 post request url(success)'),
cfg.UrlOpt('url_h', help='ipay pay with h5 post request url(fail)'),
]
# default='goperation-trusted-token',
help='Trusted token, means a unlimit user, defalut is None'
),
]
fernet_opts = [
cfg.StrOpt('fernet_key_repository',
help='fernet key dir'),
cfg.IntOpt('fernet_expire_days',
default=1, min=1, max=7,
help='fernet expire max day'),
]
manager_group = cfg.OptGroup(name=common.NAME,
title='Manager base options')
CONF.register_group(manager_group)
# goperation opts for manager
CONF.register_opts(goperation_opts, manager_group)
# database for manager
CONF.register_opts(database_opts, manager_group)
# redis for manager
CONF.register_opts(redis_opts, manager_group)
manager_conf = CONF[manager_group.name]
# rabbit for manager
rabbit_group = cfg.OptGroup(name='rabbit', title='Manager RabbitMQ base group')
CONF.register_opts(rpc_base_opts, rabbit_group)
CONF.register_opts(amqp_opts, rabbit_group)
CONF.register_opts(rabbit_opts, rabbit_group)
from simpleutil.config import cfg
from fluttercomic import common
from fluttercomic.plugin.platforms import config
CONF = cfg.CONF
NAME = 'weixin'
group = cfg.OptGroup(name='%s.%s' % (common.NAME, NAME), title='Fluttercomic WeiXin platform paypal')
weixin_opts = [
cfg.StrOpt('appId',
help='WeiXin app Id'),
cfg.StrOpt('appName',
help='WeiXin app name'),
cfg.StrOpt('mchId',
help='WeiXin mch_id'),
cfg.StrOpt('secret',
secret=True,
help='WeiXin app secret'),
cfg.StrOpt('package',
default='Sign=WXPay',
help='WeiXin package value'),
cfg.StrOpt('cert',
default='/etc/goperation/endpoints/wexin_cert.pem',
help='WeiXin SSL apiclient cert'),
cfg.StrOpt('key',
default='/etc/goperation/endpoints/wexin_key.pem',
import time import simpleservice from simpleutil.config import cfg from goperation import config from goperation.api.client import ManagerClient a = 'C:\\Users\\loliz_000\\Desktop\\etc\\goperation\\goperation.conf' b = 'C:\\Users\\loliz_000\\Desktop\\etc\\goperation\\gcenter.conf' test_group = cfg.OptGroup(name='test') config.configure(test_group, [a, b]) wsgi_url = '127.0.0.1' wsgi_port = 7999 client = ManagerClient(wsgi_url, wsgi_port) print client.ports_index(agent_id=1, endpoint='gopcdn', entity=1) # ports_index(self, agent_id, endpoint, entity, body=None) # ports_add(self, agent_id, endpoint, entity, body=None # ports_delete(self, agent_id, endpoint, entity, ports, body=None)
from simpleservice.rpc.service import LauncheRpcServiceBase
from simpleservice.server import ServerWrapper
from simpleservice.server import launch
from simpleutil.config import cfg
from simpleutil.log import log as logging
from simpleservice.rpc.target import Target
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
config_file = 'C:\\Users\\loliz_000\\Desktop\\etc\\agent.conf'
config_files = [
config_file,
]
# config.set_default_for_default_log_levels(['routes=INFO', ])
CONF(project='agent', default_config_files=config_files)
config.configure()
agent_group = cfg.OptGroup(name='agent', title='agent options')
CONF.register_group(agent_group)
logging.setup(CONF, 'agent')
default_logging.captureWarnings(True)
servers = []
manager = base.ManagerBase(Target(topic='agent', namespace='manager'))
rpc_server = LauncheRpcServiceBase(manager)
wsgi_wrapper = ServerWrapper(rpc_server, workers=1)
servers.append(wsgi_wrapper)
launch(servers)
import logging as default_logging
from simpleutil.config import cfg
from simpleutil.log import log as logging
from simpleutil.utils.threadgroup import ThreadGroup
from simpleservice import config as base_config
from goperation.filemanager import TargetFile
from goperation.filemanager import FileManager
from goperation.filemanager.config import filemanager_opts
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
fmclient_group = cfg.OptGroup(name='fmclient',
title='test filemanager api wsgi server')
def configure(version=None, config_files=None):
base_config.configure()
CONF(project=fmclient_group.name,
version=version,
default_config_files=config_files)
CONF.register_group(fmclient_group)
logging.setup(CONF, fmclient_group.name)
default_logging.captureWarnings(True)
CONF.register_opts(filemanager_opts, group=fmclient_group)
def main():
config_file = 'C:\\Users\\loliz_000\\Desktop\\etc\\filemanager\\filemanager.conf'
def configure(config_files=None, config_dirs=None):
from goperation.manager import common as manager_common
from goperation import config as goperation_config
# create a new project and group named gcenter
name = manager_common.SERVER
# init goperation config
gcenter_group = goperation_config.configure(name, config_files,
config_dirs)
# init endpoint opts
CONF.register_opts(goperation_config.endpoint_load_opts)
from simpleutil.utils import importutils
from simpleservice.wsgi.config import wsgi_server_options
from simpleservice.wsgi.config import find_paste_abs
from goperation import EXTEND_ROUTES
from goperation import OPEN_ROUTES
from goperation import CORE_ROUTES
from goperation.manager.wsgi.config import route_opts
from goperation.manager.wsgi.agent import routers as agent_routes
from goperation.manager.wsgi.file import routers as file_routes
from goperation.manager.wsgi.port import routers as port_routes
from goperation.manager.wsgi.endpoint import routers as endpoint_routes
from goperation.manager.wsgi.entity import routers as entity_routes
from goperation.manager.wsgi.cache import routers as cache_routes
from goperation.manager.wsgi.asyncrequest import routers as asyncrequest_routes
from goperation.manager.wsgi.agent.scheduler import routers as scheduler_routes
from goperation.manager.wsgi.agent.application import routers as application_routes
# insert core routes
CORE_ROUTES.extend([
port_routes, entity_routes, endpoint_routes, agent_routes,
scheduler_routes, application_routes, asyncrequest_routes,
cache_routes, file_routes
])
# set wsgi config
CONF.register_opts(wsgi_server_options, group=gcenter_group)
# set default of paste config
goperation_config.set_wsgi_default()
# add gcenter extend route
CONF.register_opts(route_opts, gcenter_group)
for cls in CONF[gcenter_group.name].routes:
# route_class = '%s.Routers' % route
EXTEND_ROUTES.append(importutils.import_module(cls))
LOG.debug('Add extend route %s success' % cls)
for cls in CONF[gcenter_group.name].publics:
# route_class = '%s.Routers' % route
OPEN_ROUTES.append(importutils.import_module(cls))
LOG.debug('Add public route %s success' % cls)
# set endpoint config
if CONF.endpoints:
for endpoint in CONF.endpoints:
endpoint_group = cfg.OptGroup(endpoint.lower(),
title='endpopint of %s' % endpoint)
CONF.register_group(endpoint_group)
CONF.register_opts(route_opts, endpoint_group)
# add endpoint route
for cls in CONF[endpoint_group.name].routes:
EXTEND_ROUTES.append(importutils.import_module(cls))
LOG.debug('Add endpoint route %s success' % cls)
for cls in CONF[endpoint_group.name].publics:
OPEN_ROUTES.append(importutils.import_module(cls))
LOG.debug('Add endpoint public route %s success' % cls)
paste_file_path = find_paste_abs(CONF[gcenter_group.name])
return gcenter_group.name, paste_file_path
import logging as default_logging
from simpleutil.config import cfg
from simpleutil.log import log as logging
from simpleservice import config as base_config
from simpleservice.wsgi.config import wsgi_options
from simpleservice.server import LaunchWrapper
from simpleservice.server import launch
from simpleservice.wsgi.factory import app_factory
from simpleservice.wsgi.service import load_paste_app
from simpleservice.wsgi.service import LauncheWsgiServiceBase
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
center_group = cfg.OptGroup(name='center', title='group of center')
def configure(version=None, config_files=None):
base_config.configure()
base_config.set_default_for_default_log_levels([
'routes=INFO',
])
CONF(project=center_group.name,
version=version,
default_config_files=config_files)
CONF.register_group(center_group)
logging.setup(CONF, center_group.name)
default_logging.captureWarnings(True)
CONF.register_opts(wsgi_options, group=center_group)
# 确认paste_deploy配置文件
