def remote_connection(request):
try:
if request.param == 'graphbinaryv1':
remote_conn = DriverRemoteConnection(
anonymous_url,
'gmodern',
message_serializer=serializer.GraphBinarySerializersV1())
elif request.param == 'graphsonv2':
remote_conn = DriverRemoteConnection(
anonymous_url,
'gmodern',
message_serializer=serializer.GraphSONSerializersV2d0())
elif request.param == 'graphsonv3':
remote_conn = DriverRemoteConnection(
anonymous_url,
'gmodern',
message_serializer=serializer.GraphSONSerializersV3d0())
else:
raise ValueError("Invalid serializer option - " + request.param)
except OSError:
pytest.skip('Gremlin Server is not running')
else:
def fin():
remote_conn.close()
request.addfinalizer(fin)
return remote_conn
def prepare_traversal_source(scenario):
# some tests create data - create a fresh remote to the empty graph and clear that graph prior to each test
remote = DriverRemoteConnection(
'ws://localhost:45940/gremlin',
"ggraph",
message_serializer=serializer.GraphSONSerializersV3d0())
scenario.context.remote_conn["empty"] = remote
g = Graph().traversal().withRemote(remote)
g.V().drop().iterate()
def __init__(self,
url,
traversal_source,
protocol_factory=None,
transport_factory=None,
pool_size=None,
max_workers=None,
message_serializer=None,
username="",
password="",
kerberized_service="",
headers=None,
session=""):
self._url = url
self._headers = headers
self._traversal_source = traversal_source
if message_serializer is None:
message_serializer = serializer.GraphSONSerializersV3d0()
self._message_serializer = message_serializer
self._username = username
self._password = password
self._session = session
self._sessionEnabled = (session != "")
if transport_factory is None:
try:
from gremlin_python.driver.tornado.transport import (
TornadoTransport)
except ImportError:
raise Exception("Please install Tornado or pass"
"custom transport factory")
else:
transport_factory = lambda: TornadoTransport()
self._transport_factory = transport_factory
if protocol_factory is None:
protocol_factory = lambda: protocol.GremlinServerWSProtocol(
self._message_serializer,
username=self._username,
password=self._password,
kerberized_service=kerberized_service)
self._protocol_factory = protocol_factory
if self._sessionEnabled:
if pool_size is None:
pool_size = 1
elif pool_size != 1:
raise Exception("PoolSize must be 1 on session mode!")
if pool_size is None:
pool_size = 4
self._pool_size = pool_size
# This is until concurrent.futures backport 3.1.0 release
if max_workers is None:
# If your application is overlapping Gremlin I/O on multiple threads
# consider passing kwarg max_workers = (cpu_count() or 1) * 5
max_workers = pool_size
self._executor = ThreadPoolExecutor(max_workers=max_workers)
# Threadsafe queue
self._pool = queue.Queue()
self._fill_pool()
def __init__(self,
url,
traversal_source,
protocol_factory=None,
transport_factory=None,
pool_size=None,
max_workers=None,
message_serializer=None,
username="",
password="",
headers=None,
ping_interval=None):
self._url = url
self._headers = headers
self._traversal_source = traversal_source
if message_serializer is None:
message_serializer = serializer.GraphSONSerializersV3d0()
self._message_serializer = message_serializer
self._username = username
self._password = password
self._ping_interval = ping_interval
if transport_factory is None:
try:
from gremlin_python.driver.tornado.transport import (
TornadoTransport)
except ImportError:
raise Exception("Please install Tornado or pass"
"custom transport factory")
else:
transport_factory = lambda: TornadoTransport()
self._transport_factory = transport_factory
if protocol_factory is None:
protocol_factory = lambda: protocol.GremlinServerWSProtocol(
self._message_serializer,
username=self._username,
password=self._password)
self._protocol_factory = protocol_factory
if pool_size is None:
pool_size = 4
self._pool_size = pool_size
# This is until concurrent.futures backport 3.1.0 release
if max_workers is None:
# Use this number because ThreadPoolExecutor is often
# used to overlap I/O instead of CPU work.
max_workers = (cpu_count() or 1) * 5
self._executor = ThreadPoolExecutor(max_workers=max_workers)
# Threadsafe queue
self._pool = queue.Queue()
self._fill_pool()
if (ping_interval):
self._ping_event_loop = asyncio.new_event_loop()
self._ping_thread = Thread(target=self.ping_server,
args=(self._ping_event_loop, ),
daemon=True)
self._ping_thread.start()
def __create_remote(server_graph_name):
if not("serializer" in world.config.user_data):
raise ValueError('test configuration requires setting of --user-data="serializer={mime-type}"')
if world.config.user_data["serializer"] == "application/vnd.gremlin-v3.0+json":
s = serializer.GraphSONSerializersV3d0()
else:
raise ValueError('serializer not found - ' + world.config.user_data["serializer"])
return DriverRemoteConnection('ws://localhost:45940/gremlin', server_graph_name, message_serializer=s)
def prepare_traversal_source(scenario):
# some tests create data - create a fresh remote to the empty graph and clear that graph prior to each test
if not ("graphson" in world.config.user_data):
raise ValueError(
'test configuration requires setting of --user-data="graphson=*" to one of [v2,v3]'
)
if world.config.user_data["graphson"] == "v3":
s = serializer.GraphSONSerializersV3d0()
elif world.config.user_data["graphson"] == "v2":
s = serializer.GraphSONSerializersV2d0()
else:
raise ValueError(
'serializer set with --user-data="graphson=v2" must be one of [v2,v3]'
)
remote = DriverRemoteConnection('ws://localhost:45940/gremlin',
"ggraph",
message_serializer=s)
scenario.context.remote_conn["empty"] = remote
g = traversal().withRemote(remote)
g.V().drop().iterate()
def __create_remote(server_graph_name):
return DriverRemoteConnection(
'ws://localhost:45940/gremlin',
server_graph_name,
message_serializer=serializer.GraphSONSerializersV3d0())
def __init__(self,
url,
traversal_source,
protocol_factory=None,
transport_factory=None,
pool_size=None,
max_workers=None,
message_serializer=None,
username="",
password="",
kerberized_service="",
headers=None,
session=None,
**transport_kwargs):
log.info("Creating Client with url '%s'", url)
self._closed = False
self._url = url
self._headers = headers
self._traversal_source = traversal_source
if "max_content_length" not in transport_kwargs:
transport_kwargs["max_content_length"] = 10 * 1024 * 1024
if message_serializer is None:
message_serializer = serializer.GraphSONSerializersV3d0()
self._message_serializer = message_serializer
self._username = username
self._password = password
self._session = session
self._session_enabled = (session is not None and session != "")
if transport_factory is None:
try:
from gremlin_python.driver.aiohttp.transport import (
AiohttpTransport)
except ImportError:
raise Exception("Please install AIOHTTP or pass "
"custom transport factory")
else:
def transport_factory():
return AiohttpTransport(**transport_kwargs)
self._transport_factory = transport_factory
if protocol_factory is None:
def protocol_factory():
return protocol.GremlinServerWSProtocol(
self._message_serializer,
username=self._username,
password=self._password,
kerberized_service=kerberized_service,
max_content_length=transport_kwargs["max_content_length"])
self._protocol_factory = protocol_factory
if self._session_enabled:
if pool_size is None:
pool_size = 1
elif pool_size != 1:
raise Exception("PoolSize must be 1 on session mode!")
if pool_size is None:
pool_size = 8
self._pool_size = pool_size
# This is until concurrent.futures backport 3.1.0 release
if max_workers is None:
# If your application is overlapping Gremlin I/O on multiple threads
# consider passing kwarg max_workers = (cpu_count() or 1) * 5
max_workers = pool_size
self._executor = ThreadPoolExecutor(max_workers=max_workers)
# Threadsafe queue
self._pool = queue.Queue()
self._fill_pool()
