fetch_openml fails on leukemia

### Describe the bug

Downloading leukemia dataset with `fetch_openml` fails

Visiting the link causing the tiemout https://openml.org/api/v1/json/data/list/data_name/leukemia/limit/2/status/active/ redirects me to 
https://old.openml.org/api/v1/json/data/list/data_name/leukemia/limit/2/status/active/ which works fine

### Steps/Code to Reproduce

```python
from sklearn.datasets import fetch_openml
fetch_openml("leukemia", data_home='inexistant_path')
```

### Expected Results

dataset downloaded 

### Actual Results



download fails :

<details> 
   
```python
  home/mathurin/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:91: UserWarning: A network error occurred while downloading https://openml.org/api/v1/json/data/list/data_name/leukemia/limit/2/status/active/. Retrying...
    warn(
  ---------------------------------------------------------------------------
  timeout                                   Traceback (most recent call last)
  File ~/anaconda3/lib/python3.9/urllib/request.py:1346, in AbstractHTTPHandler.do_open(self, http_class, req, **http_conn_args)
     1345 try:
  -> 1346     h.request(req.get_method(), req.selector, req.data, headers,
     1347               encode_chunked=req.has_header('Transfer-encoding'))
     1348 except OSError as err: # timeout error
  
  File ~/anaconda3/lib/python3.9/http/client.py:1279, in HTTPConnection.request(self, method, url, body, headers, encode_chunked)
     1278 """Send a complete request to the server."""
  -> 1279 self._send_request(method, url, body, headers, encode_chunked)
  
  File ~/anaconda3/lib/python3.9/http/client.py:1325, in HTTPConnection._send_request(self, method, url, body, headers, encode_chunked)
     1324     body = _encode(body, 'body')
  -> 1325 self.endheaders(body, encode_chunked=encode_chunked)
  
  File ~/anaconda3/lib/python3.9/http/client.py:1274, in HTTPConnection.endheaders(self, message_body, encode_chunked)
     1273     raise CannotSendHeader()
  -> 1274 self._send_output(message_body, encode_chunked=encode_chunked)
  
  File ~/anaconda3/lib/python3.9/http/client.py:1034, in HTTPConnection._send_output(self, message_body, encode_chunked)
     1033 del self._buffer[:]
  -> 1034 self.send(msg)
     1036 if message_body is not None:
     1037 
     1038     # create a consistent interface to message_body
  
  File ~/anaconda3/lib/python3.9/http/client.py:974, in HTTPConnection.send(self, data)
      973 if self.auto_open:
  --> 974     self.connect()
      975 else:
  
  File ~/anaconda3/lib/python3.9/http/client.py:1448, in HTTPSConnection.connect(self)
     1446     server_hostname = self.host
  -> 1448 self.sock = self._context.wrap_socket(self.sock,
     1449                                       server_hostname=server_hostname)
  
  File ~/anaconda3/lib/python3.9/ssl.py:500, in SSLContext.wrap_socket(self, sock, server_side, do_handshake_on_connect, suppress_ragged_eofs, server_hostname, session)
      494 def wrap_socket(self, sock, server_side=False,
      495                 do_handshake_on_connect=True,
      496                 suppress_ragged_eofs=True,
      497                 server_hostname=None, session=None):
      498     # SSLSocket class handles server_hostname encoding before it calls
      499     # ctx._wrap_socket()
  --> 500     return self.sslsocket_class._create(
      501         sock=sock,
      502         server_side=server_side,
      503         do_handshake_on_connect=do_handshake_on_connect,
      504         suppress_ragged_eofs=suppress_ragged_eofs,
      505         server_hostname=server_hostname,
      506         context=self,
      507         session=session
      508     )
  
  File ~/anaconda3/lib/python3.9/ssl.py:1040, in SSLSocket._create(cls, sock, server_side, do_handshake_on_connect, suppress_ragged_eofs, server_hostname, context, session)
     1039             raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets")
  -> 1040         self.do_handshake()
     1041 except (OSError, ValueError):
  
  File ~/anaconda3/lib/python3.9/ssl.py:1309, in SSLSocket.do_handshake(self, block)
     1308         self.settimeout(None)
  -> 1309     self._sslobj.do_handshake()
     1310 finally:
  
  timeout: _ssl.c:1112: The handshake operation timed out
  
  During handling of the above exception, another exception occurred:
  
  URLError                                  Traceback (most recent call last)
  Input In [6], in <module>
  ----> 1 fetch_openml("leukemia", data_home='inexistant_path')
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:746, in fetch_openml(name, version, data_id, data_home, target_column, cache, return_X_y, as_frame, n_retries, delay)
      740     if data_id is not None:
      741         raise ValueError(
      742             "Dataset data_id={} and name={} passed, but you can only "
      743             "specify a numeric data_id or a name, not "
      744             "both.".format(data_id, name)
      745         )
  --> 746     data_info = _get_data_info_by_name(
      747         name, version, data_home, n_retries=n_retries, delay=delay
      748     )
      749     data_id = data_info["did"]
      750 elif data_id is not None:
      751     # from the previous if statement, it is given that name is None
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:285, in _get_data_info_by_name(name, version, data_home, n_retries, delay)
      283 url = _SEARCH_NAME.format(name) + "/status/active/"
      284 error_msg = "No active dataset {} found.".format(name)
  --> 285 json_data = _get_json_content_from_openml_api(
      286     url,
      287     error_msg,
      288     data_home=data_home,
      289     n_retries=n_retries,
      290     delay=delay,
      291 )
      292 res = json_data["data"]["dataset"]
      293 if len(res) > 1:
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:229, in _get_json_content_from_openml_api(url, error_message, data_home, n_retries, delay)
      226         return json.loads(response.read().decode("utf-8"))
      228 try:
  --> 229     return _load_json()
      230 except HTTPError as error:
      231     # 412 is an OpenML specific error code, indicating a generic error
      232     # (e.g., data not found)
      233     if error.code != 412:
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:52, in _retry_with_clean_cache.<locals>.decorator.<locals>.wrapper(*args, **kw)
       50     return f(*args, **kw)
       51 try:
  ---> 52     return f(*args, **kw)
       53 except URLError:
       54     raise
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:224, in _get_json_content_from_openml_api.<locals>._load_json()
      221 @_retry_with_clean_cache(url, data_home)
      222 def _load_json():
      223     with closing(
  --> 224         _open_openml_url(url, data_home, n_retries=n_retries, delay=delay)
      225     ) as response:
      226         return json.loads(response.read().decode("utf-8"))
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:156, in _open_openml_url(openml_path, data_home, n_retries, delay)
      149 try:
      150     # Create a tmpdir as a subfolder of dir_name where the final file will
      151     # be moved to if the download is successful. This guarantees that the
      152     # renaming operation to the final location is atomic to ensure the
      153     # concurrence safety of the dataset caching mechanism.
      154     with TemporaryDirectory(dir=dir_name) as tmpdir:
      155         with closing(
  --> 156             _retry_on_network_error(n_retries, delay, req.full_url)(urlopen)(
      157                 req, timeout=delay
      158             )
      159         ) as fsrc:
      160             opener: Callable
      161             if is_gzip_encoded(fsrc):
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:84, in _retry_on_network_error.<locals>.decorator.<locals>.wrapper(*args, **kwargs)
       82 while True:
       83     try:
  ---> 84         return f(*args, **kwargs)
       85     except (URLError, TimeoutError) as e:
       86         # 412 is a specific OpenML error code.
       87         if isinstance(e, HTTPError) and e.code == 412:
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:214, in urlopen(url, data, timeout, cafile, capath, cadefault, context)
      212 else:
      213     opener = _opener
  --> 214 return opener.open(url, data, timeout)
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:517, in OpenerDirector.open(self, fullurl, data, timeout)
      514     req = meth(req)
      516 sys.audit('urllib.Request', req.full_url, req.data, req.headers, req.get_method())
  --> 517 response = self._open(req, data)
      519 # post-process response
      520 meth_name = protocol+"_response"
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:534, in OpenerDirector._open(self, req, data)
      531     return result
      533 protocol = req.type
  --> 534 result = self._call_chain(self.handle_open, protocol, protocol +
      535                           '_open', req)
      536 if result:
      537     return result
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:494, in OpenerDirector._call_chain(self, chain, kind, meth_name, *args)
      492 for handler in handlers:
      493     func = getattr(handler, meth_name)
  --> 494     result = func(*args)
      495     if result is not None:
      496         return result
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:1389, in HTTPSHandler.https_open(self, req)
     1388 def https_open(self, req):
  -> 1389     return self.do_open(http.client.HTTPSConnection, req,
     1390         context=self._context, check_hostname=self._check_hostname)
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:1349, in AbstractHTTPHandler.do_open(self, http_class, req, **http_conn_args)
     1346         h.request(req.get_method(), req.selector, req.data, headers,
     1347                   encode_chunked=req.has_header('Transfer-encoding'))
     1348     except OSError as err: # timeout error
  -> 1349         raise URLError(err)
     1350     r = h.getresponse()
     1351 except:
  
  URLError: <urlopen error _ssl.c:1112: The handshake operation timed out>
  
```
</details>

### Versions

```shell
System:
    python: 3.9.7 (default, Sep 16 2021, 13:09:58)  [GCC 7.5.0]
executable: /home/mathurin/anaconda3/bin/python
   machine: Linux-5.13.0-40-generic-x86_64-with-glibc2.31

Python dependencies:
      sklearn: 1.2.dev0
          pip: 21.2.4
   setuptools: 58.0.4
        numpy: 1.20.3
        scipy: 1.7.3
       Cython: 0.29.28
       pandas: 1.4.1
   matplotlib: 3.5.1
       joblib: 1.1.0
threadpoolctl: 2.2.0

Built with OpenMP: False

threadpoolctl info:
       filepath: /home/mathurin/anaconda3/lib/python3.9/site-packages/numpy.libs/libopenblasp-r0-5bebc122.3.13.dev.so
         prefix: libopenblas
       user_api: blas
   internal_api: openblas
        version: 0.3.13.dev
    num_threads: 8
threading_layer: pthreads
   architecture: Prescott

       filepath: /home/mathurin/anaconda3/lib/libmkl_rt.so.1
         prefix: libmkl_rt
       user_api: blas
   internal_api: mkl
        version: 2021.4-Product
    num_threads: 4
threading_layer: intel

       filepath: /home/mathurin/anaconda3/lib/libiomp5.so
         prefix: libiomp
       user_api: openmp
   internal_api: openmp
        version: None
    num_threads: 8
```

COMMENT:
I think we have seen similar errors on the CI e.g. this [build](https://app.circleci.com/pipelines/github/scikit-learn/scikit-learn/26923/workflows/81ee3da6-9181-4d5c-ad6a-2254545de348/jobs/192330).

I assumed this was a temporary issue with openml.org but I did not investigate.

~Just ran your snippet and it works fine for me ...~ **Edit**: Actually your snippet fails on 1.1.0 or main (but works on 1.0.2). The error is slightly different than yours though:

<details>

<summary>Stack-trace</summary>

```
---------------------------------------------------------------------------
timeout                                   Traceback (most recent call last)
~/dev/scikit-learn/sklearn/datasets/_openml.py in wrapper(*args, **kw)
     51             try:
---> 52                 return f(*args, **kw)
     53             except URLError:

~/dev/scikit-learn/sklearn/datasets/_openml.py in _load_json()
    223         with closing(
--> 224             _open_openml_url(url, data_home, n_retries=n_retries, delay=delay)
    225         ) as response:

~/dev/scikit-learn/sklearn/datasets/_openml.py in _open_openml_url(openml_path, data_home, n_retries, delay)
    155                 with closing(
--> 156                     _retry_on_network_error(n_retries, delay, req.full_url)(urlopen)(
    157                         req, timeout=delay

~/dev/scikit-learn/sklearn/datasets/_openml.py in wrapper(*args, **kwargs)
     83                 try:
---> 84                     return f(*args, **kwargs)
     85                 except (URLError, TimeoutError) as e:

~/miniconda3/lib/python3.9/urllib/request.py in urlopen(url, data, timeout, cafile, capath, cadefault, context)
    213         opener = _opener
--> 214     return opener.open(url, data, timeout)
    215 

~/miniconda3/lib/python3.9/urllib/request.py in open(self, fullurl, data, timeout)
    522             meth = getattr(processor, meth_name)
--> 523             response = meth(req, response)
    524 

~/miniconda3/lib/python3.9/urllib/request.py in http_response(self, request, response)
    631         if not (200 <= code < 300):
--> 632             response = self.parent.error(
    633                 'http', request, response, code, msg, hdrs)

~/miniconda3/lib/python3.9/urllib/request.py in error(self, proto, *args)
    554         args = (dict, proto, meth_name) + args
--> 555         result = self._call_chain(*args)
    556         if result:

~/miniconda3/lib/python3.9/urllib/request.py in _call_chain(self, chain, kind, meth_name, *args)
    493             func = getattr(handler, meth_name)
--> 494             result = func(*args)
    495             if result is not None:

~/miniconda3/lib/python3.9/urllib/request.py in http_error_302(self, req, fp, code, msg, headers)
    746 
--> 747         return self.parent.open(new, timeout=req.timeout)
    748 

~/miniconda3/lib/python3.9/urllib/request.py in open(self, fullurl, data, timeout)
    516         sys.audit('urllib.Request', req.full_url, req.data, req.headers, req.get_method())
--> 517         response = self._open(req, data)
    518 

~/miniconda3/lib/python3.9/urllib/request.py in _open(self, req, data)
    533         protocol = req.type
--> 534         result = self._call_chain(self.handle_open, protocol, protocol +
    535                                   '_open', req)

~/miniconda3/lib/python3.9/urllib/request.py in _call_chain(self, chain, kind, meth_name, *args)
    493             func = getattr(handler, meth_name)
--> 494             result = func(*args)
    495             if result is not None:

~/miniconda3/lib/python3.9/urllib/request.py in https_open(self, req)
   1388         def https_open(self, req):
-> 1389             return self.do_open(http.client.HTTPSConnection, req,
   1390                 context=self._context, check_hostname=self._check_hostname)

~/miniconda3/lib/python3.9/urllib/request.py in do_open(self, http_class, req, **http_conn_args)
   1349                 raise URLError(err)
-> 1350             r = h.getresponse()
   1351         except:

~/miniconda3/lib/python3.9/http/client.py in getresponse(self)
   1344             try:
-> 1345                 response.begin()
   1346             except ConnectionError:

~/miniconda3/lib/python3.9/http/client.py in begin(self)
    306         while True:
--> 307             version, status, reason = self._read_status()
    308             if status != CONTINUE:

~/miniconda3/lib/python3.9/http/client.py in _read_status(self)
    267     def _read_status(self):
--> 268         line = str(self.fp.readline(_MAXLINE + 1), "iso-8859-1")
    269         if len(line) > _MAXLINE:

~/miniconda3/lib/python3.9/socket.py in readinto(self, b)
    703             try:
--> 704                 return self._sock.recv_into(b)
    705             except timeout:

~/miniconda3/lib/python3.9/ssl.py in recv_into(self, buffer, nbytes, flags)
   1240                   self.__class__)
-> 1241             return self.read(nbytes, buffer)
   1242         else:

~/miniconda3/lib/python3.9/ssl.py in read(self, len, buffer)
   1098             if buffer is not None:
-> 1099                 return self._sslobj.read(len, buffer)
   1100             else:

timeout: The read operation timed out

During handling of the above exception, another exception occurred:

timeout                                   Traceback (most recent call last)
<ipython-input-1-c73de9ada7eb> in <module>
      1 from sklearn.datasets import fetch_openml
----> 2 fetch_openml("leukemia", data_home='inexistant_path')

~/dev/scikit-learn/sklearn/datasets/_openml.py in fetch_openml(name, version, data_id, data_home, target_column, cache, return_X_y, as_frame, n_retries, delay)
    794 
    795     # download data features, meta-info about column types
--> 796     features_list = _get_data_features(data_id, data_home)
    797 
    798     if not as_frame:

~/dev/scikit-learn/sklearn/datasets/_openml.py in _get_data_features(data_id, data_home, n_retries, delay)
    357     url = _DATA_FEATURES.format(data_id)
    358     error_message = "Dataset with data_id {} not found.".format(data_id)
--> 359     json_data = _get_json_content_from_openml_api(
    360         url,
    361         error_message,

~/dev/scikit-learn/sklearn/datasets/_openml.py in _get_json_content_from_openml_api(url, error_message, data_home, n_retries, delay)
    227 
    228     try:
--> 229         return _load_json()
    230     except HTTPError as error:
    231         # 412 is an OpenML specific error code, indicating a generic error

~/dev/scikit-learn/sklearn/datasets/_openml.py in wrapper(*args, **kw)
     58                 if os.path.exists(local_path):
     59                     os.unlink(local_path)
---> 60                 return f(*args, **kw)
     61 
     62         return wrapper

~/dev/scikit-learn/sklearn/datasets/_openml.py in _load_json()
    222     def _load_json():
    223         with closing(
--> 224             _open_openml_url(url, data_home, n_retries=n_retries, delay=delay)
    225         ) as response:
    226             return json.loads(response.read().decode("utf-8"))

~/dev/scikit-learn/sklearn/datasets/_openml.py in _open_openml_url(openml_path, data_home, n_retries, delay)
    154             with TemporaryDirectory(dir=dir_name) as tmpdir:
    155                 with closing(
--> 156                     _retry_on_network_error(n_retries, delay, req.full_url)(urlopen)(
    157                         req, timeout=delay
    158                     )

~/dev/scikit-learn/sklearn/datasets/_openml.py in wrapper(*args, **kwargs)
     82             while True:
     83                 try:
---> 84                     return f(*args, **kwargs)
     85                 except (URLError, TimeoutError) as e:
     86                     # 412 is a specific OpenML error code.

~/miniconda3/lib/python3.9/urllib/request.py in urlopen(url, data, timeout, cafile, capath, cadefault, context)
    212     else:
    213         opener = _opener
--> 214     return opener.open(url, data, timeout)
    215 
    216 def install_opener(opener):

~/miniconda3/lib/python3.9/urllib/request.py in open(self, fullurl, data, timeout)
    521         for processor in self.process_response.get(protocol, []):
    522             meth = getattr(processor, meth_name)
--> 523             response = meth(req, response)
    524 
    525         return response

~/miniconda3/lib/python3.9/urllib/request.py in http_response(self, request, response)
    630         # request was successfully received, understood, and accepted.
    631         if not (200 <= code < 300):
--> 632             response = self.parent.error(
    633                 'http', request, response, code, msg, hdrs)
    634 

~/miniconda3/lib/python3.9/urllib/request.py in error(self, proto, *args)
    553             http_err = 0
    554         args = (dict, proto, meth_name) + args
--> 555         result = self._call_chain(*args)
    556         if result:
    557             return result

~/miniconda3/lib/python3.9/urllib/request.py in _call_chain(self, chain, kind, meth_name, *args)
    492         for handler in handlers:
    493             func = getattr(handler, meth_name)
--> 494             result = func(*args)
    495             if result is not None:
    496                 return result

~/miniconda3/lib/python3.9/urllib/request.py in http_error_302(self, req, fp, code, msg, headers)
    745         fp.close()
    746 
--> 747         return self.parent.open(new, timeout=req.timeout)
    748 
    749     http_error_301 = http_error_303 = http_error_307 = http_error_302

~/miniconda3/lib/python3.9/urllib/request.py in open(self, fullurl, data, timeout)
    515 
    516         sys.audit('urllib.Request', req.full_url, req.data, req.headers, req.get_method())
--> 517         response = self._open(req, data)
    518 
    519         # post-process response

~/miniconda3/lib/python3.9/urllib/request.py in _open(self, req, data)
    532 
    533         protocol = req.type
--> 534         result = self._call_chain(self.handle_open, protocol, protocol +
    535                                   '_open', req)
    536         if result:

~/miniconda3/lib/python3.9/urllib/request.py in _call_chain(self, chain, kind, meth_name, *args)
    492         for handler in handlers:
    493             func = getattr(handler, meth_name)
--> 494             result = func(*args)
    495             if result is not None:
    496                 return result

~/miniconda3/lib/python3.9/urllib/request.py in https_open(self, req)
   1387 
   1388         def https_open(self, req):
-> 1389             return self.do_open(http.client.HTTPSConnection, req,
   1390                 context=self._context, check_hostname=self._check_hostname)
   1391 

~/miniconda3/lib/python3.9/urllib/request.py in do_open(self, http_class, req, **http_conn_args)
   1348             except OSError as err: # timeout error
   1349                 raise URLError(err)
-> 1350             r = h.getresponse()
   1351         except:
   1352             h.close()

~/miniconda3/lib/python3.9/http/client.py in getresponse(self)
   1343         try:
   1344             try:
-> 1345                 response.begin()
   1346             except ConnectionError:
   1347                 self.close()

~/miniconda3/lib/python3.9/http/client.py in begin(self)
    305         # read until we get a non-100 response
    306         while True:
--> 307             version, status, reason = self._read_status()
    308             if status != CONTINUE:
    309                 break

~/miniconda3/lib/python3.9/http/client.py in _read_status(self)
    266 
    267     def _read_status(self):
--> 268         line = str(self.fp.readline(_MAXLINE + 1), "iso-8859-1")
    269         if len(line) > _MAXLINE:
    270             raise LineTooLong("status line")

~/miniconda3/lib/python3.9/socket.py in readinto(self, b)
    702         while True:
    703             try:
--> 704                 return self._sock.recv_into(b)
    705             except timeout:
    706                 self._timeout_occurred = True

~/miniconda3/lib/python3.9/ssl.py in recv_into(self, buffer, nbytes, flags)
   1239                   "non-zero flags not allowed in calls to recv_into() on %s" %
   1240                   self.__class__)
-> 1241             return self.read(nbytes, buffer)
   1242         else:
   1243             return super().recv_into(buffer, nbytes, flags)

~/miniconda3/lib/python3.9/ssl.py in read(self, len, buffer)
   1097         try:
   1098             if buffer is not None:
-> 1099                 return self._sslobj.read(len, buffer)
   1100             else:
   1101                 return self._sslobj.read(len)

timeout: The read operation timed out
```

</details>

Labels: Bug