[ZEPPELIN-6245] Improve Repository class stability and validation

# Improve Repository Class Stability and Validation

## Summary

This PR enhances the `Repository` class with comprehensive input validation, error handling, and stability improvements to ensure robust Maven repository configuration management.

## Changes Made

### 1. Enhanced Input Validation
- **Repository ID validation**: Added regex pattern validation to ensure IDs contain only alphanumeric characters, dots, underscores, and hyphens
- **URL validation**: Implemented URL format validation supporting HTTP, HTTPS, and FILE protocols
- **Credentials validation**: Added validation to ensure both username and password are provided together
- **Proxy validation**: Added comprehensive proxy configuration validation including protocol, host, and port checks

### 2. Improved Error Handling
- **Custom Exception**: Created `RepositoryException` class for Repository-specific errors
- **JSON parsing**: Enhanced error handling for malformed JSON with descriptive error messages
- **Validation errors**: Comprehensive error messages for all validation failures

### 3. Builder Pattern Enhancements
- **Method chaining**: Improved builder pattern with proper validation at each step
- **Fluent API**: Enhanced usability with intuitive method names and return types

### 4. JSON Serialization Improvements
- **Robust parsing**: Enhanced `fromJson()` method with comprehensive validation
- **Backward compatibility**: Maintained compatibility with existing JSON formats
- **Error resilience**: Graceful handling of invalid JSON inputs

### 5. Documentation and Code Quality
- **Comprehensive JavaDoc**: Added detailed documentation with examples and parameter descriptions
- **Usage examples**: Included code examples in class-level documentation
- **Validation documentation**: Clear documentation of all validation rules

## Benefits

1. **Improved Reliability**: Input validation prevents runtime errors from malformed configurations
2. **Better Error Messages**: Clear, actionable error messages help users identify and fix configuration issues
3. **Enhanced Security**: URL and credential validation prevents potential security issues
4. **Maintainability**: Clean, well-documented code with comprehensive test coverage
5. **User Experience**: Better error handling and validation feedback

## Testing

- All existing tests pass
- New comprehensive test suite covers edge cases and validation scenarios
- Integration tests verify backward compatibility
- Manual testing confirms REST API functionality

## Example Usage

```java
// Basic repository configuration
Repository repo = new Repository("central")
    .url("https://repo.maven.apache.org/maven2/");

// Repository with authentication
Repository privateRepo = new Repository("private")
    .url("https://private.repo/maven2/")
    .credentials("username", "password");

// Repository with proxy configuration
Repository proxyRepo = new Repository("proxy-repo")
    .url("https://repo.example.com/maven2/")
    .proxy("HTTP", "proxy.host", 8080, "proxyUser", "proxyPass");
```


Closes #4977 from renechoi/improve-repository-validation.

Signed-off-by: Philipp Dallig <philipp.dallig@gmail.com>

Author: renechoi

zeppelin-interpreter/src/main/java/org/apache/zeppelin/dep/Repository.java

@@ -0,0 +1,32 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.zeppelin.dep;
+
+/**
+ * Exception thrown when there are issues with Repository configuration or operations.
+ */
+public class RepositoryException extends RuntimeException {
+
+  public RepositoryException(String message) {
+    super(message);
+  }
+
+  public RepositoryException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}

zeppelin-interpreter/src/main/java/org/apache/zeppelin/dep/RepositoryException.java

@@ -0,0 +1,303 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.zeppelin.dep;
+
+import org.eclipse.aether.repository.RemoteRepository;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RepositoryTest {
+
+  @Test
+  void testToRemoteRepository() {
+    // Test basic repository conversion
+    Repository repo = new Repository.Builder("test-repo")
+        .url("https://repo.maven.apache.org/maven2/")
+        .build();
+    
+    RemoteRepository remoteRepo = repo.toRemoteRepository();
+    
+    assertEquals("test-repo", remoteRepo.getId());
+    assertEquals("https://repo.maven.apache.org/maven2/", remoteRepo.getUrl());
+    assertEquals("default", remoteRepo.getContentType());
+    assertNotNull(remoteRepo.getPolicy(false));
+    assertTrue(remoteRepo.getPolicy(false).isEnabled());
+  }
+
+  @Test
+  void testToRemoteRepositoryWithSnapshot() {
+    Repository repo = new Repository.Builder("snapshot-repo")
+        .url("https://repo.maven.apache.org/maven2/")
+        .snapshot()
+        .build();
+    
+    RemoteRepository remoteRepo = repo.toRemoteRepository();
+    
+    assertEquals("snapshot-repo", remoteRepo.getId());
+    assertTrue(remoteRepo.getPolicy(true).isEnabled());
+  }
+
+  @Test
+  void testToRemoteRepositoryWithAuthentication() {
+    Repository repo = new Repository.Builder("auth-repo")
+        .url("https://private.repo/maven2/")
+        .credentials("user", "pass")
+        .build();
+    
+    RemoteRepository remoteRepo = repo.toRemoteRepository();
+    
+    assertNotNull(remoteRepo.getAuthentication());
+  }
+
+  @Test
+  void testToRemoteRepositoryWithProxy() {
+    Repository repo = new Repository.Builder("proxy-repo")
+        .url("https://repo.maven.apache.org/maven2/")
+        .proxy("HTTP", "proxy.host", 8080, "proxyUser", "proxyPass")
+        .build();
+    
+    RemoteRepository remoteRepo = repo.toRemoteRepository();
+    
+    assertNotNull(remoteRepo.getProxy());
+    assertEquals("proxy.host", remoteRepo.getProxy().getHost());
+    assertEquals(8080, remoteRepo.getProxy().getPort());
+  }
+
+  @Test
+  void testFromRemoteRepository() {
+    RemoteRepository remoteRepo = new RemoteRepository.Builder("central", "default", 
+        "https://repo.maven.apache.org/maven2/")
+        .setReleasePolicy(new org.eclipse.aether.repository.RepositoryPolicy(true, null, null))
+        .setSnapshotPolicy(new org.eclipse.aether.repository.RepositoryPolicy(false, null, null))
+        .build();
+    
+    Repository repo = Repository.fromRemoteRepository(remoteRepo);
+    
+    assertEquals("central", repo.getId());
+    assertEquals("https://repo.maven.apache.org/maven2/", repo.getUrl());
+    assertFalse(repo.isSnapshot());
+  }
+
+  @Test
+  void testFromRemoteRepositoryWithSnapshot() {
+    RemoteRepository remoteRepo = new RemoteRepository.Builder("snapshots", "default", 
+        "https://repo.maven.apache.org/maven2/")
+        .setSnapshotPolicy(new org.eclipse.aether.repository.RepositoryPolicy(true, null, null))
+        .build();
+    
+    Repository repo = Repository.fromRemoteRepository(remoteRepo);
+    
+    assertEquals("snapshots", repo.getId());
+    assertTrue(repo.isSnapshot());
+  }
+
+  @Test
+  void testRoundTripConversion() {
+    // Test that conversion is consistent (with data loss for auth/proxy)
+    Repository original = new Repository.Builder("test")
+        .url("https://test.repo/maven2/")
+        .snapshot()
+        .build();
+    
+    RemoteRepository remote = original.toRemoteRepository();
+    Repository converted = Repository.fromRemoteRepository(remote);
+    
+    assertEquals(original.getId(), converted.getId());
+    assertEquals(original.getUrl(), converted.getUrl());
+    assertEquals(original.isSnapshot(), converted.isSnapshot());
+  }
+
+  @Test
+  void testJsonSerialization() {
+    Repository repo = new Repository.Builder("json-test")
+        .url("https://test.repo/")
+        .credentials("user", "pass")
+        .proxy("HTTP", "proxy", 8080, "puser", "ppass")
+        .build();
+    
+    String json = repo.toJson();
+    Repository deserialized = Repository.fromJson(json);
+    
+    assertEquals(repo.getId(), deserialized.getId());
+    assertEquals(repo.getUrl(), deserialized.getUrl());
+    // Test that credentials are preserved in JSON
+    assertNotNull(deserialized.getAuthentication());
+    assertNotNull(deserialized.getProxy());
+  }
+
+  // Input validation tests
+  @Test
+  void testInvalidRepositoryId() {
+    // Test null ID
+    assertThrows(RepositoryException.class, () -> new Repository.Builder(null));
+    
+    // Test empty ID
+    assertThrows(RepositoryException.class, () -> new Repository.Builder(""));
+    
+    // Test invalid characters in ID
+    assertThrows(RepositoryException.class, () -> new Repository.Builder("repo@invalid"));
+    assertThrows(RepositoryException.class, () -> new Repository.Builder("repo with spaces"));
+    assertThrows(RepositoryException.class, () -> new Repository.Builder("repo/with/slash"));
+  }
+
+  @Test
+  void testValidRepositoryId() {
+    // Test valid IDs
+    assertDoesNotThrow(() -> new Repository.Builder("central").build());
+    assertDoesNotThrow(() -> new Repository.Builder("my-repo").build());
+    assertDoesNotThrow(() -> new Repository.Builder("repo_123").build());
+    assertDoesNotThrow(() -> new Repository.Builder("repo.with.dots").build());
+    assertDoesNotThrow(() -> new Repository.Builder("123-repo-456").build());
+  }
+
+  @Test
+  void testInvalidUrl() {
+    Repository.Builder builder = new Repository.Builder("test");
+    
+    // Test null URL
+    assertThrows(RepositoryException.class, () -> builder.url(null));
+    
+    // Test empty URL
+    assertThrows(RepositoryException.class, () -> builder.url(""));
+    
+    // Test invalid URL format
+    assertThrows(RepositoryException.class, () -> builder.url("not-a-url"));
+    assertThrows(RepositoryException.class, () -> builder.url("ftp://invalid-protocol"));
+  }
+
+  @Test
+  void testValidUrl() {
+    Repository.Builder builder = new Repository.Builder("test");
+    
+    // Test valid URLs
+    assertDoesNotThrow(() -> builder.url("https://repo.maven.apache.org/maven2/").build());
+    assertDoesNotThrow(() -> builder.url("http://localhost:8080/nexus/").build());
+    assertDoesNotThrow(() -> builder.url("file:///home/user/.m2/repository/").build());
+  }
+
+  @Test
+  void testInvalidCredentials() {
+    Repository.Builder builder = new Repository.Builder("test");
+    
+    // Test username without password
+    assertThrows(RepositoryException.class, () -> builder.credentials("user", null));
+    assertThrows(RepositoryException.class, () -> builder.credentials("user", ""));
+    
+    // Test password without username
+    assertThrows(RepositoryException.class, () -> builder.credentials(null, "pass"));
+    assertThrows(RepositoryException.class, () -> builder.credentials("", "pass"));
+  }
+
+  @Test
+  void testValidCredentials() {
+    Repository.Builder builder = new Repository.Builder("test");
+    
+    // Test valid credentials
+    assertDoesNotThrow(() -> builder.credentials("user", "pass").build());
+    assertDoesNotThrow(() -> builder.credentials(null, null).build());
+  }
+
+  @Test
+  void testInvalidProxy() {
+    Repository.Builder builder = new Repository.Builder("test");
+    
+    // Test invalid protocol
+    assertThrows(RepositoryException.class, () -> builder.proxy("FTP", "proxy.host", 8080, null, null));
+    assertThrows(RepositoryException.class, () -> builder.proxy(null, "proxy.host", 8080, null, null));
+    assertThrows(RepositoryException.class, () -> builder.proxy("", "proxy.host", 8080, null, null));
+    
+    // Test invalid host
+    assertThrows(RepositoryException.class, () -> builder.proxy("HTTP", null, 8080, null, null));
+    assertThrows(RepositoryException.class, () -> builder.proxy("HTTP", "", 8080, null, null));
+    
+    // Test invalid port
+    assertThrows(RepositoryException.class, () -> builder.proxy("HTTP", "proxy.host", 0, null, null));
+    assertThrows(RepositoryException.class, () -> builder.proxy("HTTP", "proxy.host", -1, null, null));
+    assertThrows(RepositoryException.class, () -> builder.proxy("HTTP", "proxy.host", 65536, null, null));
+  }
+
+  @Test
+  void testValidProxy() {
+    Repository.Builder builder = new Repository.Builder("test");
+    
+    // Test valid proxy configurations
+    assertDoesNotThrow(() -> builder.proxy("HTTP", "proxy.host", 8080, null, null).build());
+    assertDoesNotThrow(() -> new Repository.Builder("test2").proxy("HTTPS", "proxy.host", 443, "user", "pass").build());
+    assertDoesNotThrow(() -> new Repository.Builder("test3").proxy("http", "proxy.host", 3128, null, null).build()); // case insensitive
+  }
+
+  @Test
+  void testInvalidJsonDeserialization() {
+    // Test null JSON
+    assertThrows(RepositoryException.class, () -> Repository.fromJson(null));
+    
+    // Test empty JSON
+    assertThrows(RepositoryException.class, () -> Repository.fromJson(""));
+    
+    // Test invalid JSON format
+    assertThrows(RepositoryException.class, () -> Repository.fromJson("not-json"));
+    assertThrows(RepositoryException.class, () -> Repository.fromJson("{invalid json}"));
+    
+    // Test JSON that results in null
+    assertThrows(RepositoryException.class, () -> Repository.fromJson("null"));
+  }
+
+  @Test
+  void testValidJsonDeserialization() {
+    String validJson = "{\"id\":\"test\",\"url\":\"https://repo.maven.apache.org/maven2/\",\"snapshot\":false}";
+    
+    assertDoesNotThrow(() -> {
+      Repository repo = Repository.fromJson(validJson);
+      assertEquals("test", repo.getId());
+      assertEquals("https://repo.maven.apache.org/maven2/", repo.getUrl());
+      assertFalse(repo.isSnapshot());
+    });
+  }
+
+  @Test
+  void testToRemoteRepositoryValidation() {
+    // Test with missing URL
+    Repository repo = new Repository.Builder("test").build();
+    assertThrows(RepositoryException.class, () -> repo.toRemoteRepository());
+    
+    // Test with valid repository
+    Repository validRepo = new Repository.Builder("test")
+        .url("https://repo.maven.apache.org/maven2/")
+        .build();
+    assertDoesNotThrow(() -> validRepo.toRemoteRepository());
+  }
+
+  @Test
+  void testFromRemoteRepositoryValidation() {
+    // Test with null RemoteRepository
+    assertThrows(RepositoryException.class, () -> Repository.fromRemoteRepository(null));
+  }
+
+  @Test
+  void testBackwardCompatibilityWithEmptyUrl() {
+    // Test that repositories with empty URLs can be parsed (for backward compatibility)
+    String jsonWithoutUrl = "{\"id\":\"test\",\"snapshot\":false}";
+    
+    assertDoesNotThrow(() -> {
+      Repository repo = Repository.fromJson(jsonWithoutUrl);
+      assertEquals("test", repo.getId());
+      assertNull(repo.getUrl());
+    });
+  }
+}

zeppelin-interpreter/src/test/java/org/apache/zeppelin/dep/RepositoryTest.java

@@ -261,8 +261,7 @@ public Response listRepositories() {
   public Response addRepository(String message) {
     try {
       Repository request = Repository.fromJson(message);
-      interpreterSettingManager.addRepository(request.getId(), request.getUrl(),
-          request.isSnapshot(), request.getAuthentication(), request.getProxy());
+      interpreterSettingManager.addRepository(request);
       LOGGER.info("New repository {} added", request.getId());
     } catch (Exception e) {
       LOGGER.error("Exception in InterpreterRestApi while adding repository ", e);