def _connect_to_db(self, retries=0): """ Connect to the database, but do not initialize a connection. Depending on which public method is used, it initiates either a standard mongo connection or a gridfs connection """ retries = retries try: # Establish a Connection connection = pymongo.Connection(self.host, self.port, **self.options) # Establish a database database = connection[self.db] # If user passed username and password args, give that to authenticate if self.username and self.password: database.authenticate(self.username, self.password) # Handle the following exceptions, if retries is less than what is # passed into this method, attempt to connect again. Otherwise, # raise the proper exception. except AutoReconnect, error_message: time.sleep(2) retries += 1 if retries <= self.max_retries: self._connect_to_db(retries=retries) else: raise ConnectionFailure('Max number of retries (%s) reached. Error: %s'\ % (self.max_retries, error_message))
def _configured_socket(address, options): """Given (host, port) and PoolOptions, return a configured socket. Can raise socket.error, ConnectionFailure, or CertificateError. Sets socket's SSL and timeout options. """ sock = _create_connection(address, options) ssl_context = options.ssl_context if ssl_context is not None: try: sock = ssl_context.wrap_socket(sock) except IOError as exc: sock.close() raise ConnectionFailure("SSL handshake failed: %s" % (str(exc), )) if ssl_context.verify_mode and options.ssl_match_hostname: try: match_hostname(sock.getpeercert(), hostname=address[0]) except CertificateError: sock.close() raise sock.settimeout(options.socket_timeout) return sock
def __receive_data_on_socket(self, length, sock): """Lowest level receive operation. Takes length to receive and repeatedly calls recv until able to return a buffer of that length, raising ConnectionFailure on error. """ message = "" while len(message) < length: try: chunk = sock.recv(length - len(message)) except: # Store the exception from sock.recv() in case we throw a new # exception in this exception-handler. exc_type, exc_value, exc_traceback = sys.exc_info() # PYTHON-294: must close socket here, because if it remains open # after this then the next time we read from it we may get stale # data from a previous operation. try: self.__pool.discard_socket() except: pass raise exc_value if chunk == "": raise ConnectionFailure("connection closed") message += chunk return message
def test__mongoAdminCommand_connect_failed(self, mongo_client_mock): mongo_client_mock.return_value.admin.command.side_effect = ( ConnectionFailure("connection attempt failed"), self._getFixture("initiate-ok")) result = self.service._executeAdminCommand(self.cluster_object, "replSetGetStatus") self.assertEqual(self.initiate_ok_response, result)
def connect(self, host, port): """Connect to Mongo and return a new (connected) socket. """ try: # Prefer IPv4. If there is demand for an option # to specify one or the other we can add it later. s = socket.socket(socket.AF_INET) s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) s.settimeout(self.conn_timeout or 20.0) s.connect((host, port)) except socket.gaierror: # If that fails try IPv6 s = socket.socket(socket.AF_INET6) s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) s.settimeout(self.conn_timeout or 20.0) s.connect((host, port)) if self.use_ssl: try: s = ssl.wrap_socket(s) except ssl.SSLError: s.close() raise ConnectionFailure("SSL handshake failed. MongoDB may " "not be configured with SSL support.") s.settimeout(self.net_timeout) return s
def open_connection(self): try: password = os.getenv('MONGODB_PASSWORD') if not password: raise ConnectionFailure( "No MongoDB password found in .env file under the key 'MONGODB_PASSWORD'." ) self.client = pymongo.MongoClient( f'mongodb+srv://{self.USER_NAME}:{password}@zbot-5waud.gcp.mongodb.net/test?retryWrites=true' ) self.client.admin.command( 'ismaster' ) # Check if connected and raises ConnectionFailure if not logger.info( f"Connected to MongoDB database '{self.DATABASE_NAME}'.") self.connected = True self.database = self.client[self.DATABASE_NAME] for collection_name in self.COLLECTION_NAMES: self.collections[collection_name] = self.database[ collection_name] logger.info(f"Loaded {len(self.collections)} collection(s).") except ConnectionFailure: logger.error( f"Could not connect to MongoDB database '{self.DATABASE_NAME}'.", exc_info=True) return self.connected
def __init__( self, url: str = DEFAULT_URL, db: str = DEFAULT_DB, check_connection: bool = True, ): """Constructor. Args: url: MongoDB server URL db: MongoDB 'database' (namespace) to use check_connection: If True, check immediately if we can connect to the server at the provided url. Otherwise defer this check until the first operation (at which point a stack trace may occur). Raises: pymongo.errors.ConnectionFailure: if check_connection is True, and the connection fails """ self._mongoclient_connect_status = {"initial": "untried", "retry": "untried"} self._client = self._mongoclient(url, check_connection, **self.timeout_args) if self._client is None: msg = self.connect_status_str _log.error(msg) raise ConnectionFailure(msg) self._db = getattr(self._client, db) self._db = getattr(self._client, db) self._database_name = db self._server_url = url
def _configured_socket(address, options): """Given (host, port) and PoolOptions, return a configured socket. Can raise socket.error, ConnectionFailure, or CertificateError. Sets socket's SSL and timeout options. """ sock = _create_connection(address, options) ssl_context = options.ssl_context if ssl_context is not None: host = address[0] try: # According to RFC6066, section 3, IPv4 and IPv6 literals are # not permitted for SNI hostname. if _HAVE_SNI and not is_ip_address(host): sock = ssl_context.wrap_socket(sock, server_hostname=host) else: sock = ssl_context.wrap_socket(sock) except IOError as exc: sock.close() raise ConnectionFailure("SSL handshake failed: %s" % (str(exc),)) if ssl_context.verify_mode and options.ssl_match_hostname: try: match_hostname(sock.getpeercert(), hostname=host) except CertificateError: sock.close() raise sock.settimeout(options.socket_timeout) return sock
async def read_loop(self) -> None: while True: try: await self._read_loop_step() except asyncio.CancelledError: self._shut_down() return except Exception as e: self.__connected.clear() connection_error = ConnectionFailure( 'Connection was lost due to: {}'.format(str(e))) self.close(error=connection_error) for ft in self.__request_futures.values(): if not ft.done(): ft.set_exception(connection_error) self.__request_futures = {} if self.reconnect_task is None: self.reconnect_task = asyncio.ensure_future( self.reconnect()) self.reconnect_task.add_done_callback( self._on_reconnect_task_done) else: logger.warning('Reconnect already in progress') return
def _shut_down(self) -> None: connection_error = ConnectionFailure('Shutting down.') for ft in self.__request_futures.values(): if not ft.done(): ft.set_exception(connection_error) self.__disconnected.set()
def connect(self): """Connect to Mongo and return a new (connected) socket. Note that the pool does not keep a reference to the socket -- you must call return_socket() when you're done with it. """ sock = self.create_connection() hostname = self.pair[0] if self.use_ssl: try: sock = ssl.wrap_socket(sock, certfile=self.ssl_certfile, keyfile=self.ssl_keyfile, ca_certs=self.ssl_ca_certs, cert_reqs=self.ssl_cert_reqs) if self.ssl_cert_reqs and self.ssl_match_hostname: match_hostname(sock.getpeercert(), hostname) except ssl.SSLError: sock.close() raise ConnectionFailure("SSL handshake failed. MongoDB may " "not be configured with SSL support.") sock.settimeout(self.net_timeout) return SocketInfo(sock, self.pool_id, hostname)
def __init__(self): self.client = None self.connected = False self.database = None self.collections = {} self.database_host = os.getenv('MONGODB_DATABASE_HOST') self.database_name = os.getenv('MONGODB_DATABASE_NAME') if not self.database_host: raise ConnectionFailure( "No MongoDB host found in .env file under the key 'MONGODB_HOST'." ) if not self.database_name: raise ConnectionFailure( "No MongoDB database name found in .env file under the key 'MONGODB_DATABASE_NAME'." )
def unset_config(email, key): try: result = barry_db.users.update_one({'email': email}, {'$unset': { 'config.' + key: '' }}) except: raise ConnectionFailure("Failed to connect to the database")
def test__mongoAdminCommand_NoPrimary(self, mongo_client_mock): mongo_client_mock.return_value.admin.command.side_effect = ( ConnectionFailure( "No replica set members match selector \"Primary()\""), self._getFixture("initiate-ok"), self._getFixture("initiate-ok")) self.service._executeAdminCommand(self.cluster_object, "replSetGetStatus")
def test_standalone_error(self): responses = (('a', 27017), ConnectionFailure("SPECIAL MESSAGE")) uri = "mongodb://a:27017" expected_results = [ 'ServerHeartbeatStartedEvent', 'ServerHeartbeatFailedEvent' ] self.create_mock_monitor(responses, uri, expected_results)
def setUp(self): try: self.db = connect_to_db('localhost', 37017) except AutoReconnect as e: raise ConnectionFailure('Could not connect to MongoDB client. Make' ' sure a tunnel is set up (or some other ' 'method is used) before running the ' 'tests.')
def __init__(self, client, port, database, collection): self.conn = MongoClient(client, port) self.database = self.conn[database] self.collection = self.database[collection] try: self.conn.admin.command('ismaster') except ConnectionFailure: raise ConnectionFailure("error")
def __recv_data(self, length, sock): """Lowest level receive operation. Takes length to receive and repeatedly calls recv until able to return a buffer of that length, raising ConnectionFailure on error. """ chunks = [] while length: try: chunk = sock.recv(length) except: raise ConnectionFailure("connection error") if chunk == "": raise ConnectionFailure("connection closed") length -= len(chunk) chunks.append(chunk) return "".join(chunks)
def test_heartbeat_raises_exception_when_connection_alive_is_false(self, *calls): # pylint: disable=W0613 with patch('mongodb_proxy.MongoProxy') as mock_proxy: mock_proxy.return_value.admin.command.side_effect = ConnectionFailure('Test') useless_conn = MongoConnection('useless', 'useless', 'useless') with pytest.raises(HeartbeatFailure): useless_conn.heartbeat()
def get_config(email, key): try: user = barry_db.users.find_one({'email': email}) except: raise ConnectionFailure("Failed to connect to the database") if 'config' in user and key in user['config']: return user['config'][key] raise Exception("No such key in user configs")
def get_database(self, database=None): """ Retrieves a database from an existing connection. """ if not self.connection: raise ConnectionFailure('No connection') if not database: if not self._database: raise Exception('No database submitted') database = self._database return self.connection[database]
def _raise_wait_queue_timeout(self): listeners = self.opts.event_listeners if self.enabled_for_cmap: listeners.publish_connection_check_out_failed( self.address, ConnectionCheckOutFailedReason.TIMEOUT) raise ConnectionFailure( 'Timed out while checking out a connection from connection pool ' 'with max_size %r and wait_queue_timeout %r' % (self.opts.max_pool_size, self.opts.wait_queue_timeout))
def list_config(email): try: user = barry_db.users.find_one({'email': email}) except: raise ConnectionFailure("Failed to connect to the database") if 'config' in user: return user['config'] return {}
def get_db(): try: # Check the connection was successful client.admin.command('ismaster') return client[DB_NAME] except ConnectionFailure as e: print(f"Server not available: {e}") raise ConnectionFailure( f"Was unable to connect to the database: {MONGO_DB}")
def open_connection(self): """ Establish MongoDB client connection. """ self.client = pymongo.MongoClient(self._mongo_uri) if self.client is None: raise ConnectionFailure('No client connection: {}').format( self._mongo_uri) self.db = self.client[self._mongo_db] self.collection = self.db[self._mongo_collection]
def create_connection(self): """Connect and return a socket object. This is a modified version of create_connection from CPython >=2.6. """ host, port = self.pair # Check if dealing with a unix domain socket if host.endswith('.sock'): if not hasattr(socket, "AF_UNIX"): raise ConnectionFailure("UNIX-sockets are not supported " "on this system") sock = socket.socket(socket.AF_UNIX) try: sock.connect(host) return sock except socket.error as e: if sock is not None: sock.close() raise e # Don't try IPv6 if we don't support it. Also skip it if host # is 'localhost' (::1 is fine). Avoids slow connect issues # like PYTHON-356. family = socket.AF_INET if socket.has_ipv6 and host != 'localhost': family = socket.AF_UNSPEC err = None for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM): af, socktype, proto, dummy, sa = res sock = None try: sock = socket.socket(af, socktype, proto) sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, self.socket_keepalive) sock.settimeout(self.conn_timeout) sock.connect(sa) return sock except socket.error as e: err = e if sock is not None: sock.close() if err is not None: raise err else: # This likely means we tried to connect to an IPv6 only # host with an OS/kernel or Python interpreter that doesn't # support IPv6. The test case is Jython2.5.1 which doesn't # support IPv6 at all. raise socket.error('getaddrinfo failed')
def g(arg1, counter=[0]): if counter[0] == 0: counter[0] += 1 print "NetworkTimeout" raise NetworkTimeout("FOO") elif counter[0] == 1: counter[0] += 1 print "Connection Failure" raise ConnectionFailure("BAR") else: return True
def __init__(self): handlers = urls settings = dict(autoescape=None, ) tornado.web.Application.__init__(self, handlers, **settings) try: self.con = MongoClient(config_test.DB_CONN_STR) self.database = self.con[config_test.DB_NAME] except Exception as e: raise ConnectionFailure("Failed to connect to db", e)
def __next__(self): if len(self.dataBuffer) < 16: return None message_length, = struct.unpack("<i", self.dataBuffer[:4]) if len(self.dataBuffer) < message_length: return None if message_length < 16: raise ConnectionFailure() message_data = self.dataBuffer[:message_length] self.dataBuffer = self.dataBuffer[message_length:] return self.decode(message_data)
def _connect(self): try: self.client = pymongo.MongoClient(self.host,self.port, serverSelectionTimeoutMS=database_connect_time_out,connectTimeoutMS=database_connect_time_out) self.client.server_info() msg = 'host: {} port: {} database_name : {} MongoDB数据库连接成功'.format(host, port, self.database) logger.info(msg) self.db = self.client[self.database] except ServerSelectionTimeoutError as e: msg = 'host: {} port: {} database_name : {} MongoDB数据库连接失败 原因: 可能配置文件出错或者连接超时 超时时间为: {} 毫秒'.format(host, port, self.database, database_connect_time_out) raise ConnectionFailure(msg)