def _apply_base_uri(self, uri):
assert uri
parsed = urlsplit(uri)
if parsed.scheme is None:
self.__secure = None
self.__verify = None
self.__scheme = None
else:
self.__scheme = parsed.scheme
if self.__scheme in [
"bolt+s", "bolt+ssc", "https", "http+s", "http+ssc"
]:
self.__secure = True
elif self.__scheme in ["bolt", "http"]:
self.__secure = False
else:
raise ValueError("Unsupported scheme %r "
"(for routing, use routing=True)" %
self.__scheme)
if self.__scheme in ["bolt+ssc", "http+ssc"]:
self.__verify = False
else:
self.__verify = True
self.__user = parsed.username or None
self.__password = parsed.password or None
netloc = parsed.netloc
if "@" in netloc:
self.__address = Address.parse(netloc.partition("@")[-1])
else:
self.__address = Address.parse(netloc)
def begin(self, graph_name, readonly=False,
# after=None, metadata=None, timeout=None
):
if graph_name and not self.supports_multi():
raise TypeError("Neo4j {} does not support "
"named graphs".format(self.neo4j_version))
if readonly:
raise TypeError("Readonly transactions are not supported over HTTP")
# if after:
# raise TypeError("Bookmarks are not supported over HTTP")
# if metadata:
# raise TypeError("Transaction metadata is not supported over HTTP")
# if timeout:
# raise TypeError("Transaction timeouts are not supported over HTTP")
try:
r = self._post(HTTPTransaction.begin_uri(graph_name))
except ConnectionError as error:
raise_from(TransactionError("Transaction failed to begin"), error)
except HTTPError as error:
raise_from(TransactionError("Transaction failed to begin"), error)
else:
if r.status != 201:
raise TransactionError("Transaction failed to begin "
"due to HTTP status %r" % r.status)
rs = HTTPResponse.from_json(r.status, r.data.decode("utf-8"))
location_path = urlsplit(r.headers["Location"]).path
tx = HTTPTransaction(graph_name, location_path.rpartition("/")[-1])
self.release()
rs.audit(tx)
return tx
def sync(self):
ref = self.ref
# Some of the transactional URIs do not support empty statement
# lists in versions earlier than 2.3. Which doesn't really matter
# as it's a waste sending anything anyway.
if ref in (self.autocommit_ref, self.begin_ref,
self.transaction_ref) and not self._statements:
return 0
count = 0
try:
response = self.post(ref, {"statements": self._statements},
expected=(OK, CREATED))
if response.status == 201:
location_path = urlsplit(response.headers["Location"]).path
self.transaction_ref = "".join(
location_path.rpartition("transaction")[1:])
self.commit_ref = "%s/commit" % self.transaction_ref
self.ref = self.transaction_ref
content = json_loads(response.data.decode("utf-8"))
errors = content["errors"]
if errors:
from py2neo.graph import GraphError
raise GraphError.hydrate(errors[0])
for i, result_loader in enumerate(self._result_loaders):
try:
count += result_loader.load(content["results"][i])
except IndexError:
result_loader.fail()
return count
finally:
self._statements[:] = ()
self._result_loaders[:] = ()
def begin(self,
graph_name,
readonly=False,
after=None,
metadata=None,
timeout=None):
if graph_name and not self.supports_multi():
raise TypeError("Neo4j {} does not support "
"named graphs".format(self.neo4j_version))
if readonly:
raise TypeError(
"Readonly transactions are not supported over HTTP")
if after:
raise TypeError("Bookmarks are not supported over HTTP")
if metadata:
raise TypeError("Transaction metadata is not supported over HTTP")
if timeout:
raise TypeError("Transaction timeouts are not supported over HTTP")
r = self._post(HTTPTransaction.begin_uri(graph_name))
if r.status != 201:
raise RuntimeError(
"Can't begin a new transaction") # TODO: better error
rs = HTTPResponse.from_json(r.data.decode("utf-8"))
location_path = urlsplit(r.headers["Location"]).path
tx = HTTPTransaction(graph_name, location_path.rpartition("/")[-1])
self._transactions.add(tx)
self.release()
rs.audit(tx)
return tx
def __init__(self, uri=None, **parts):
parsed = urlsplit(uri or "")
self.secure = parts.get("secure", False)
self.scheme = parts.get(
"scheme") or parsed.scheme or self.default_scheme(self.secure)
if self.scheme == "https":
self.secure = True
self.host = (parts.get("%s_host" % self.scheme) or parts.get("host")
or parsed.hostname or self.default_host())
self.port = (parts.get("%s_port" % self.scheme) or parts.get("port")
or parsed.port or self.default_port(self.scheme))
def _apply_uri(self, uri):
settings = {}
parsed = urlsplit(uri)
if parsed.scheme is not None:
self._apply_scheme(parsed.scheme)
if "@" in parsed.netloc:
settings["address"] = parsed.netloc.partition("@")[-1]
else:
settings["address"] = parsed.netloc
if parsed.username:
settings["user"] = parsed.username
if parsed.password:
settings["password"] = parsed.password
self._apply_settings(**settings)
def __init__(self, uri):
self.uri = uri
parts = urlsplit(uri)
scheme = parts.scheme
host = parts.hostname
port = parts.port
if scheme == "http":
from urllib3 import HTTPConnectionPool
self._http = HTTPConnectionPool("%s:%d" % (host, port))
elif scheme == "https":
from urllib3 import HTTPSConnectionPool
self._http = HTTPSConnectionPool("%s:%d" % (host, port))
else:
raise ValueError("Unsupported scheme %r" % scheme)
self.path = parts.path
self._headers = get_http_headers(scheme, host, port)
def _apply_base_uri(self, uri):
assert uri
parsed = urlsplit(uri)
if parsed.scheme is not None:
self.__scheme = parsed.scheme
if self.__scheme in [
"bolt+s", "bolt+ssc", "https", "http+s", "http+ssc"
]:
self.__secure = True
elif self.__scheme in ["bolt", "http"]:
self.__secure = False
if self.__scheme in ["bolt+ssc", "http+ssc"]:
self.__verify = False
else:
self.__verify = True
self.__user = parsed.username or None
self.__password = parsed.password or None
netloc = parsed.netloc
if "@" in netloc:
self.__address = Address.parse(netloc.partition("@")[-1])
else:
self.__address = Address.parse(netloc)
def begin(self, graph_name, readonly=False,
# after=None, metadata=None, timeout=None
):
if graph_name and not self.supports_multi():
raise TypeError("Neo4j {} does not support "
"named graphs".format(self.neo4j_version))
try:
# if readonly:
# log.warning("Readonly transactions are not supported over HTTP")
# if after:
# raise TypeError("Bookmarks are not supported over HTTP")
# if metadata:
# raise TypeError("Transaction metadata is not supported over HTTP")
# if timeout:
# raise TypeError("Transaction timeouts are not supported over HTTP")
r = self._post(HTTPTransactionRef.begin_uri(graph_name))
rs = HTTPResponse.from_json(r.status, r.data.decode("utf-8"))
location_path = urlsplit(r.headers["Location"]).path
tx = HTTPTransactionRef(graph_name, location_path.rpartition("/")[-1])
rs.audit(tx)
return tx
finally:
self.release()
def apply_uri(u):
parsed = urlsplit(u)
if parsed.username:
apply_auth(parsed.username + ":" + parsed.password)