__init__.py

#!/usr/bin/env python
# --coding:utf-8--
 
# Copyright (c) 2020 vesoft inc. All rights reserved.
#
# This source code is licensed under Apache 2.0 License.
 
 
import socket
 
from nebula3.Exception import InValidHostname
from nebula3.storage import GraphStorageService
from nebula3.fbthrift.transport import TSocket, THeaderTransport, TTransport
from nebula3.fbthrift.protocol import THeaderProtocol
 
 
class GraphStorageConnection(object):
    def __init__(self, address, timeout, meta_cache):
        self._address_address = address
        self._timeout_timeout = timeout
        self._meta_cache_meta_cache = meta_cache
        self._connection_connection = None
        self._ip_ip = ''
        try:
            self._ip_ip = socket.gethostbyname(address.host)
            if not isinstance(address.port, int):
                raise RuntimeError('Wrong port type: {}'.format(type(address.port)))
        except Exception:
            raise InValidHostname(str(address.host))
 
    def open(self):
        try:
            self.closeclose()
            s = TSocket.TSocket(self._address_address.host, self._address_address.port)
            if self._timeout_timeout > 0:
                s.setTimeout(self._timeout_timeout)
 
            buffered_transport = TTransport.TBufferedTransport(s)
            header_transport = THeaderTransport.THeaderTransport(buffered_transport)
            protocol = THeaderProtocol.THeaderProtocol(header_transport)
            header_transport.open()
 
            self._connection_connection = GraphStorageService.Client(protocol)
        except Exception:
            raise
 
    def scan_vertex(self, req):
        return self._connection_connection.scanVertex(req)
 
    def scan_edge(self, req):
        return self._connection_connection.scanEdge(req)
 
    def storage_addr(self):
        return self._address_address
 
    def update_leader_info(self, space_id, part_id, address):
        self._meta_cache_meta_cache.update_storage_leader(space_id, part_id, address)
 
    def close(self):
        try:
            if self._connection_connection is not None:
                self._connection_connection._iprot.trans.close()
        except Exception:
            raise
 
    def __del__(self):
        self.closeclose()