def __init__(self, server, thriftmod, timeout=0, frame_transport=False):
'''server - 为Selector对象，或者地址{'addr':('127.0.0.1',5000),'timeout':1000}'''
self.starttime = time.time()
self.server_selector = None
self.server = None
self.client = None
self.thriftmod = thriftmod
self.frame_transport = frame_transport
self.raise_except = False # 是否在调用时抛出异常
self.timeout = timeout
if isinstance(server, dict): # 只有一个server
self.server = [
server,
]
self.server_selector = selector.Selector(self.server, 'random')
elif isinstance(server, list): # server列表，需要创建selector，策略为随机
self.server = server
self.server_selector = selector.Selector(self.server, 'random')
else: # 直接是selector
self.server_selector = server
while True:
if self.open() == 0:
break
def testValidDoubleSubset(self):
selector_file_contents = """{
"file_format_version": 1,
"duration": "30d",
"metric":"average_rtt",
"ip_translation":{
"strategy":"maxmind",
"params":{
"db_snapshots":["2014-08-04"]
}
},
"subsets":[
{
"site":"lga02",
"client_provider":"comcast",
"start_time":"2014-02-01T00:00:00Z"
},
{
"site":"lga01",
"client_provider":"comcast",
"start_time":"2014-02-01T00:00:00Z"
}
]
}"""
selector1_expected = selector.Selector()
selector1_expected.start_time = utils.make_datetime_utc_aware(
datetime.datetime(2014, 2, 1))
selector1_expected.duration = 30 * 24 * 60 * 60
selector1_expected.metric = 'average_rtt'
selector1_expected.site_name = 'lga02'
selector1_expected.ip_translation_spec = (
iptranslation.IPTranslationStrategySpec(
'maxmind', {'db_snapshots': ['2014-08-04']}))
selector1_expected.client_provider = 'comcast'
selector2_expected = selector.Selector()
selector2_expected.start_time = utils.make_datetime_utc_aware(
datetime.datetime(2014, 2, 1))
selector2_expected.duration = 30 * 24 * 60 * 60
selector2_expected.metric = 'average_rtt'
selector2_expected.ip_translation_spec = (
iptranslation.IPTranslationStrategySpec(
'maxmind', {'db_snapshots': ['2014-08-04']}))
selector2_expected.site_name = 'lga01'
selector2_expected.client_provider = 'comcast'
selectors_expected = [selector1_expected, selector2_expected]
self.assertParsedSelectorsMatch(selectors_expected,
selector_file_contents)
def testValidInput_v1dot1_EmptyListValue_OptionalParameter(self):
"""Empty list on optional parameter (client_countries) is handled as None"""
selector_file_contents = """{
"file_format_version": 1.1,
"duration": "30d",
"metrics": ["average_rtt"],
"ip_translation":{
"strategy":"maxmind",
"params":{
"db_snapshots":["2014-08-04"]
}
},
"client_countries": [],
"start_times": ["2014-02-01T00:00:00Z"]
}"""
selector_expected = selector.Selector()
selector_expected.start_time = utils.make_datetime_utc_aware(
datetime.datetime(2014, 2, 1))
selector_expected.duration = 30 * 24 * 60 * 60
selector_expected.metric = 'average_rtt'
selector_expected.ip_translation_spec = (
iptranslation.IPTranslationStrategySpec(
'maxmind', {'db_snapshots': ['2014-08-04']}))
selector_expected.client_country = None
self.assertParsedSingleSelectorMatches(selector_expected,
selector_file_contents)
def testValidInput_v1dot1_Simple_SingleLocationValues_onlyClientCountries(
self):
selector_file_contents = """{
"file_format_version": 1.1,
"duration": "30d",
"metrics": ["average_rtt"],
"ip_translation":{
"strategy":"maxmind",
"params":{
"db_snapshots":["2014-08-04"]
}
},
"client_countries": ["us"],
"start_times": ["2014-02-01T00:00:00Z"]
}"""
selector_expected = selector.Selector()
selector_expected.start_time = utils.make_datetime_utc_aware(
datetime.datetime(2014, 2, 1))
selector_expected.duration = 30 * 24 * 60 * 60
selector_expected.metric = 'average_rtt'
selector_expected.ip_translation_spec = (
iptranslation.IPTranslationStrategySpec(
'maxmind', {'db_snapshots': ['2014-08-04']}))
selector_expected.client_country = 'us'
self.assertParsedSingleSelectorMatches(selector_expected,
selector_file_contents)
def test():
from qfcommon.thriftclient.payprocessor import PayProcessor
from qfcommon.base import logger
global log
logger.install('stdout')
log = logger.log
log.debug('test ...')
serverlist = [
{
'addr': ('127.0.0.1', 4300),
'timeout': 1000
},
{
'addr': ('127.0.0.1', 4200),
'timeout': 1000
},
]
sel = selector.Selector(serverlist)
for i in range(0, 10):
client = ThriftClient(sel, PayProcessor)
client.ping()
server = sel.next()
server['valid'] = False
#log.debug('restore ...')
#restore(sel)
print '-' * 60
for i in range(0, 10):
client = ThriftClient(sel, PayProcessor)
client.ping()
def make_wsgi_app():
# BasicAuth applications
create = AuthBasicHandler(BlogCreate, 'www', authfunc)
update = AuthBasicHandler(BlogUpdate, 'www', authfunc)
delete = AuthBasicHandler(BlogDelete, 'www', authfunc)
# URL dispatching middleware
dispatch = selector.Selector()
dispatch.add('/', GET=BlogIndex)
dispatch.prefix = '/article'
dispatch.add('/add', GET=create, POST=create)
dispatch.add('/{id:digits}', GET=BlogRead)
dispatch.add('/{id:digits}/edit', GET=update, POST=update)
dispatch.add('/{id:digits}/delete', GET=delete)
# Static files
from paste.urlparser import StaticURLParser
static_app = StaticURLParser("my_wsgi_blog/static/")
from paste import urlmap
mapping = urlmap.URLMap()
mapping['/static'] = static_app
from paste.cascade import Cascade
app = Cascade([mapping, dispatch])
return app
def round_trip(self, algorithm='naive', log_level=logging.WARNING):
fileh = logging.FileHandler(f'./log/{algorithm}-{logging.getLevelName(log_level)}.log', 'w', encoding='utf-8')
# formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
formatter = logging.Formatter('%(message)s')
fileh.setFormatter(formatter)
log = logging.getLogger() # root logger
for hdlr in log.handlers[:]: # remove all old handlers
log.removeHandler(hdlr)
log.addHandler(fileh) # set the new handler
log.setLevel(log_level)
selector_tester = ''
if algorithm == 'naive':
logging.debug('using naive select algorithm')
selector_tester = selector.Selector()
if algorithm == 'linear':
logging.debug('using linear select algorithm')
selector_tester = linear_selector.LinearSelector()
elif algorithm == 'lazy':
logging.debug('using lazy select algorithm')
selector_tester = lazy_selector.LazySelector()
A = np.array([4, 7, 2, 10, 3, 3])
# x = selector.min(A, 2)
# logging.warning(f'min({A}, 2) = {x}')
for i in range(len(A)):
begin = time.time()
x = selector_tester.min(A, i)
end = time.time()
logging.warning(f'min({A}, {i}) = {x}')
logging.warning(f'Time used: {end-begin}seconds')
fileh.close()
def testEncodeSimpleSelectorB(self):
s = selector.Selector()
s.start_time = datetime.datetime(2014, 2, 1)
s.duration = 22
s.site_name = 'lga02'
s.client_provider = 'comcast'
s.metric = 'download_throughput'
s.ip_translation_spec = (iptranslation.IPTranslationStrategySpec(
'maxmind', {'db_snapshots': ['2014-08-04']}))
encoded_expected = """
{
"file_format_version": 1.0,
"duration": "22d",
"metric":"download_throughput",
"ip_translation":{
"strategy":"maxmind",
"params":{
"db_snapshots":["2014-08-04"]
}
},
"subsets":[
{
"site":"lga02",
"client_provider":"comcast",
"start_time":"2014-02-01T00:00:00Z"
}
]
}"""
encoded_actual = selector.SelectorJsonEncoder().encode(s)
self.assertJsonEqual(encoded_expected, encoded_actual)
def testValidInput_v1dot1_Simple_CountriesCaseInsensitivity(self):
selector_file_contents = """{
"file_format_version": 1.1,
"duration": "30d",
"metrics": ["average_rtt"],
"ip_translation":{
"strategy":"maxmind",
"params":{
"db_snapshots":["2014-08-04"]
}
},
"start_times": ["2014-02-01T00:00:00Z"],
"client_countries": ["us", "Ca", "uK", "AU"]
}"""
selectors_expected = []
selector_base = selector.Selector()
selector_base.start_time = utils.make_datetime_utc_aware(
datetime.datetime(2014, 2, 1))
selector_base.duration = 30 * 24 * 60 * 60
selector_base.metric = "average_rtt"
selector_base.ip_translation_spec = (
iptranslation.IPTranslationStrategySpec(
'maxmind', {'db_snapshots': ['2014-08-04']}))
for client_country in ('us', 'ca', 'uk', 'au'):
selector_copy = copy.copy(selector_base)
selector_copy.client_country = client_country
selectors_expected.append(selector_copy)
self.assertParsedSelectorsMatch(selectors_expected,
selector_file_contents)
def test__line_parse_comments_and_blanks_ignored():
"""Blank and are ignored by the parser."""
s = flexmock(selector.Selector())
assert s._parse_line("", None, None) == (None, None)
assert s._parse_line(" # ", None, None) == (None, None)
assert s._parse_line("", 1, 2) == (1, 2)
assert s._parse_line(" # ", 3, 4) == (3, 4)
def test_selector_call():
"""Call should call select, munge environ and call app."""
s = selector.Selector()
def checker(environ, start_response):
print environ
assert len(environ.keys()) == 7
assert start_response == 1
assert environ['selector.methods'] == ['GET', 'POST']
assert environ['selector.vars'] == {
'1': 'two',
'0': 'one',
'name': 'luke'
}
assert environ['wsgiorg.routing_args'][0] == ['one', 'two']
assert environ['wsgiorg.routing_args'][1] == {'name': 'luke'}
assert environ['PATH_INFO'] == ''
assert environ['SCRIPT_NAME'] == '/path'
assert environ['REQUEST_METHOD'] == 'GET'
return 'output'
# Mock select
(flexmock(s).should_receive('select').once.with_args(
'/path', 'GET').replace_with(lambda x, y: (checker, {
'name': 'luke',
'__pos0': 'one',
'__pos1': 'two'
}, ['GET', 'POST'], '/path')))
returned = s({'PATH_INFO': '/path', 'REQUEST_METHOD': 'GET'}, 1)
assert returned == 'output'
def __init__(self,
tmdbfile,
tmfiles,
max_candidates=3,
min_similarity=75,
max_length=1000,
prefix="",
source_lang=None,
target_lang=None):
if not isinstance(tmdbfile, six.text_type):
import sys
tmdbfile = tmdbfile.decode(sys.getfilesystemencoding())
self.tmdb = tmdb.TMDB(tmdbfile, max_candidates, min_similarity,
max_length)
if tmfiles:
self._load_files(tmfiles, source_lang, target_lang)
#initialize url dispatcher
self.rest = selector.Selector(prefix=prefix)
self.rest.add("/{slang}/{tlang}/unit/{uid:any}",
GET=self.translate_unit,
POST=self.update_unit,
PUT=self.add_unit,
DELETE=self.forget_unit)
self.rest.add("/{slang}/{tlang}/store/{sid:any}",
GET=self.get_store_stats,
PUT=self.upload_store,
POST=self.add_store,
DELETE=self.forget_store)
def testEncodeSimpleSelectorA(self):
s = selector.Selector()
s.start_time = datetime.datetime(2015, 4, 2, 10, 27, 34)
s.duration = 45
s.site_name = 'mia01'
s.client_provider = 'twc'
s.metric = 'upload_throughput'
s.ip_translation_spec = (iptranslation.IPTranslationStrategySpec(
'maxmind', {'db_snapshots': ['2015-02-05']}))
encoded_expected = """
{
"file_format_version": 1.0,
"duration": "45d",
"metric":"upload_throughput",
"ip_translation":{
"strategy":"maxmind",
"params":{
"db_snapshots":["2015-02-05"]
}
},
"subsets":[
{
"site":"mia01",
"client_provider":"twc",
"start_time":"2015-04-02T10:27:34Z"
}
]
}"""
encoded_actual = selector.SelectorJsonEncoder().encode(s)
self.assertJsonEqual(encoded_expected, encoded_actual)
def testSuccessfulParseOfValidv1_1FileWithAllOptionalFieldsDefined(self):
selector_file_contents = """{
"file_format_version": 1.1,
"duration": "30d",
"metrics": ["average_rtt"],
"ip_translation":{
"strategy":"maxmind",
"params":{
"db_snapshots":["2014-08-04"]
}
},
"sites": ["lga02"],
"client_providers": ["comcast"],
"client_countries": ["us"],
"start_times": ["2014-02-01T00:00:00Z"]
}"""
selector_expected = selector.Selector()
selector_expected.start_time = utils.make_datetime_utc_aware(
datetime.datetime(2014, 2, 1))
selector_expected.duration = 30 * 24 * 60 * 60
selector_expected.metric = 'average_rtt'
selector_expected.ip_translation_spec = (
iptranslation.IPTranslationStrategySpec(
'maxmind', {'db_snapshots': ['2014-08-04']}))
selector_expected.site = 'lga02'
selector_expected.client_provider = 'comcast'
selector_expected.client_country = 'us'
self.assertParsedSingleSelectorMatches(selector_expected,
selector_file_contents)
def test_instantiate_selector_defaults():
"""Instantiate a `Selector()`, hold-the-mayo please."""
s = selector.Selector()
s.mappings = []
s.prefix is None
s.parser.__class__ is selector.SimpleParser
s.wrap is None
s.consume_path is True
def test_selector_slurp_file_exception():
"""Slurping a file adds mappings.."""
flexmock(resolver).should_receive('resolve').replace_with(lambda x: 1)
mocks.mock_open('test_selector_slurp_file',
[" GET whatever.foo:app", "/some-url/"])
s = selector.Selector()
flexmock(s).should_receive('add').times(0)
with pytest.raises(selector.MappingFileError):
s.slurp_file('test_selector_slurp_file')
def do_capture_area():
handle_delay()
ffb = lookitconfig.LookitConfig().getboolean('General', 'force_fallback')
selection = selector.Selector().get_selection(ffb)
if selection is None:
show_notification('Lookit', 'Selection cancelled')
return
pb = screencapper.capture_selection(selection)
return uploader.upload_pixbuf(pb)
def test_selector_slurp_file():
"""Slurping a file adds mappings.."""
flexmock(resolver).should_receive('resolve').replace_with(lambda x: 1)
mocks.mock_open('test_selector_slurp_file',
["/some-url/", " GET whatever.foo:app"])
s = selector.Selector()
(flexmock(s).should_receive('add').once.with_args('/some-url/', {
'GET': 1
}).replace_with(mocks.checkadd(s, '', s.parser, None)))
s.slurp_file('test_selector_slurp_file')
def test_add_keyword():
"""Add mapping using keyword for HTTP method."""
s = selector.Selector(parser=lambda x: x + 'p')
(flexmock(re).should_receive('compile')
.once.with_args('/foop')
.replace_with(lambda x: x + "c"))
result = s.add('/foo', GET=33)
assert result[0] == '/foopc' # 'pc' as in "parsed and compiled"
assert result[1].keys() == ['GET']
assert result[1].values() == [33]
assert len(s.mappings) == 1
def test_add_dict_override():
"""Add mapping using keyword and dict (keyword wins)."""
s = selector.Selector(parser=lambda x: x + 'p')
(flexmock(re).should_receive('compile')
.once.with_args('/foop')
.replace_with(lambda x: x + "c"))
result = s.add('/foo', method_dict=dict(GET=33), GET=34)
assert result[0] == '/foopc' # 'pc' as in "parsed and compiled"
assert result[1].keys() == ['GET']
assert result[1].values() == [34]
assert len(s.mappings) == 1
def test_add_prefix():
"""Add mapping using prefix option."""
s = selector.Selector(parser=lambda x: x + 'p')
(flexmock(re).should_receive('compile')
.once.with_args('/pre/foop')
.replace_with(lambda x: x + "c"))
assert s.prefix == ''
result = s.add('/foo', GET=33, prefix='/pre')
assert s.prefix == ''
assert result[0] == '/pre/foopc' # 'pc' as in "parsed and compiled"
assert result[1].keys() == ['GET']
assert result[1].values() == [33]
assert len(s.mappings) == 1
def test_select_404():
"""The path was not matched."""
s = selector.Selector()
s.mappings = [
(mocks.mock_regex(), {
'GET': 1
}),
]
app, svars, methods, matched = s.select('/foo', 'GET')
assert app is s.status404
assert svars == {}
assert methods == []
assert matched == ""
def test_slurp_the_works():
"""Slurp with prefix, parser and wrap."""
myparser = lambda x: x
mywrap = lambda x: x
s = selector.Selector()
assert s.prefix == ''
assert s.parser.__class__ == selector.SimpleParser
assert s.wrap is None
flexmock(s).should_receive('add').times(2).replace_with(
mocks.checkadd(s, '/pre', myparser, mywrap))
s.slurp(mocks.slurpables, prefix='/pre', parser=myparser, wrap=mywrap)
assert s.prefix == ''
assert s.parser.__class__ == selector.SimpleParser
assert s.wrap is None
def test__line_parse_processing_directives():
"""Route adding is modulated by `@` directives."""
flexmock(resolver).should_receive('resolve').replace_with(lambda x: 1)
s = flexmock(selector.Selector(), add=None)
assert s.prefix == ''
assert s._parse_line("@prefix /pre", None, None) == (None, None)
assert s.prefix == '/pre'
assert s._parse_line("@prefix", None, None) == (None, None)
assert s.prefix == ''
assert s.parser.__class__ is selector.SimpleParser
assert s._parse_line("@parser whatever", None, None) == (None, None)
assert s.parser == 1
assert s.wrap == None
assert s._parse_line("@wrap whatever", None, None) == (None, None)
assert s.wrap == 1
def test__line_parse_path_expressions_and_http_methods():
"""Path expressions collect HTTP method -> handler maps."""
flexmock(resolver).should_receive('resolve').replace_with(lambda x: 1)
s = flexmock(selector.Selector(), add=None)
s.should_receive('add').once
assert s._parse_line("/path", None, None) == ('/path', {})
assert (s._parse_line(" GET foo:Bar", '/path', {}) == ('/path', {
'GET': 1
}))
assert (s._parse_line(" PUT foo:Put", '/path', {'GET': 1}) == ('/path', {
'PUT': 1,
'GET': 1
}))
assert (s._parse_line("/bar", '/path', {'GET': 1}) == ('/bar', {}))
print dir(s)
def make_wsgi_app():
# BasicAuth applications
create = AuthBasicHandler(BlogCreate, 'www', authfunc)
update = AuthBasicHandler(BlogUpdate, 'www', authfunc)
delete = AuthBasicHandler(BlogDelete, 'www', authfunc)
# URL dispatching middleware
dispatch = selector.Selector()
dispatch.add('/', GET=BlogIndex)
dispatch.prefix = '/article'
dispatch.add('/add', GET=create, POST=create)
dispatch.add('/{id:digits}', GET=BlogRead)
dispatch.add('/{id:digits}/edit', GET=update, POST=update)
dispatch.add('/{id:digits}/delete', GET=delete)
return dispatch
def __init__(self, parent=None):
super(Main_window, self).__init__(parent)
self.setWindowTitle("Renders shape-files with PyShp and PyQt4")
self.view = GraphicsView(self.statusBar())
self.setCentralWidget(self.view)
self.scene = QtGui.QGraphicsScene(self)
self.view.setScene(self.scene)
dock = QtGui.QDockWidget("Shape files")
self.addDockWidget(QtCore.Qt.BottomDockWidgetArea, dock)
self.tab_widget = QtGui.QTabWidget()
dock.setWidget(self.tab_widget)
self.selector = selector.Selector(self)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.selector)
def test_select_405():
"""The path matches but the method is not supported."""
s = selector.Selector()
s.mappings = [
(mocks.mock_regex(), {
'GET': 1
}),
(mocks.mock_regex('/foo'), {
'POST': 2
}),
]
app, svars, methods, matched = s.select('/foo', 'GET')
assert app is s.status405
assert svars == {}
assert methods == ['POST']
assert matched == ""
def test_selector_slurp_file_with_options():
"""Slurp in a file with the works.."""
flexmock(resolver).should_receive('resolve').replace_with(lambda x: 1)
mocks.mock_open('test_selector_slurp_file',
["/some-url/", " GET whatever.foo:app"])
s = selector.Selector()
(flexmock(s).should_receive('add').once.with_args('/some-url/', {
'GET': 1
}).replace_with(mocks.checkadd(s, '/pre', 2, 3)))
assert s.prefix == ''
assert s.parser.__class__ == selector.SimpleParser
assert s.wrap is None
s.slurp_file('test_selector_slurp_file', prefix='/pre', parser=2, wrap=3)
assert s.prefix == ''
assert s.parser.__class__ == selector.SimpleParser
assert s.wrap is None
def make_wsgi_app():
passwd = {'admin': '123'}
# BasicAuth applications
create = BasicAuth(BlogCreate, 'www', passwd)
update = BasicAuth(BlogUpdate, 'www', passwd)
delete = BasicAuth(BlogDelete, 'www', passwd)
# URL dispatching middleware
dispatch = selector.Selector()
dispatch.add('/', GET=BlogIndex)
dispatch.prefix = '/article'
dispatch.add('/add', GET=create, POST=create)
dispatch.add('/{id:digits}', GET=BlogRead)
dispatch.add('/{id:digits}/edit', GET=update, POST=update)
dispatch.add('/{id:digits}/delete', GET=delete)
return dispatch
