voonhous commented on code in PR #19470:
URL: https://github.com/apache/hudi/pull/19470#discussion_r3703288623
##########
hudi-hadoop-common/src/main/java/org/apache/hudi/hadoop/fs/HoodieRetryWrapperFileSystem.java:
##########
@@ -277,7 +277,7 @@ public Configuration getConf() {
@Override
public String getScheme() {
- return fileSystem.getScheme();
+ return HadoopFSUtils.getScheme(fileSystem);
Review Comment:
**The only regression guard in the tree for this line cannot fail, and has
not been able to since the day it merged.**
`e88b4748127c` (HUDI-5286, #7313, "UnsupportedOperationException throws when
enabling filesystem retry") added *both* this override and
`TestFSUtilsWithRetryWrapperEnable#testGetSchema`. That test is inert for two
independent reasons:
1. It asserts on `HoodieWrapperFileSystem#getScheme()`, which is `return
uri.getScheme()` and never dispatches into the retry wrapper. Already true when
the test shipped -- `git show
e88b4748127c^:hudi-common/src/main/java/org/apache/hudi/common/fs/HoodieWrapperFileSystem.java
| sed -n '415,417p'`.
2. The same commit gave `FakeRemoteFileSystem` a `getScheme()` override
(`TestFSUtilsWithRetryWrapperEnable.java:257-260`) delegating to a real
`LocalFileSystem`, so it cannot throw.
A/B on this branch: pre-PR `HoodieRetryWrapperFileSystem#getScheme()` throws
`UnsupportedOperationException`, post-PR it returns `file`. The assertion's
value is `file` either way, so your change here ships untested.
`FakeRemoteFileSystem` already overrides `getUri()` (`:145`), so deleting
its `getScheme()` override gives it exactly the `PrestoS3FileSystem` shape.
Please delete `TestFSUtilsWithRetryWrapperEnable.java:257-260` and retarget the
assertion at the wrapper itself:
```java
assertEquals("file", ((HoodieRetryWrapperFileSystem)
fileSystem).getScheme());
```
Three lines, and a four-year-old no-op becomes the actual guard for both
HUDI-5286 and this PR.
##########
hudi-hadoop-common/src/main/java/org/apache/hudi/storage/hadoop/HoodieHadoopStorage.java:
##########
@@ -111,7 +111,7 @@ public HoodieStorage newInstance(StoragePath path,
StorageConfiguration<?> stora
@Override
public String getScheme() {
- return fs.getScheme();
+ return HadoopFSUtils.getScheme(fs);
Review Comment:
**Perf, non-blocking:** on exactly the filesystem class this PR targets, the
scheme is now re-resolved through a thrown-and-caught
`UnsupportedOperationException` once per log block.
Call frequency, all on the read/write hot path:
- `HoodieLogFileReader.java:139` -> `:258`
`StorageSchemes.isWriteTransactional(storage.getScheme())` -- **once per log
block**.
- `HoodieStorage.java:390-396` `needCreateTempFile()` calls `getScheme()`
**three times** per immutable-file write, and on an S3-like scheme all three
miss; reached per partition via `HoodiePartitionMetadata.java:116`.
- `HadoopFSUtils.java:223,228` -- 2 more per `getFSDataInputStream`.
Measured cost of the fallback (exception construction is dominated by
stack-trace fill-in, so it scales with engine call depth):
| stack depth | fallback | direct |
| --- | --- | --- |
| +0 | 321 ns/call | 4 ns/call |
| +40 | 1188 ns/call | 1 ns/call |
| +80 | 1923 ns/call | 1 ns/call |
Small next to S3 IO, hence not a blocker, but it is pure waste on this PR's
own target path and `fs` is `final`. Please memoize:
```java
private final Lazy<String> scheme = Lazy.lazily(() ->
HadoopFSUtils.getScheme(fs));
@Override
public String getScheme() {
return scheme.get();
}
```
(`org.apache.hudi.common.util.Lazy`; a lazy field avoids touching all five
constructors.)
##########
hudi-hadoop-common/src/test/java/org/apache/hudi/hadoop/fs/TestHadoopFSUtils.java:
##########
@@ -22,22 +22,80 @@
import org.apache.hudi.storage.StoragePath;
import org.apache.hudi.storage.StoragePathInfo;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.FilterFileSystem;
import org.apache.hadoop.fs.Path;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+
import static
org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToHadoopFileStatus;
import static org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToHadoopPath;
import static org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToStoragePath;
import static org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToStoragePathInfo;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* Tests {@link HadoopFSUtils}
*/
public class TestHadoopFSUtils {
+ /**
+ * HUDI-4602: {@link FileSystem#getScheme()} is optional in Hadoop -- the
base implementation throws
+ * {@link UnsupportedOperationException} -- and proxy implementations such
as Presto's
+ * {@code PrestoS3FileSystem} do not override it. Opening a log file went
straight through
+ * {@code isGCSFileSystem}, so a MOR {@code _rt} query on Presto failed with
+ * "Not implemented by the PrestoS3FileSystem FileSystem implementation"
rather than reading anything.
+ *
+ * <p>{@link FilterFileSystem} has the same shape: it leaves {@code
getScheme()} to the throwing base
+ * implementation while overriding {@code getUri()}.
+ */
+ @Test
+ public void testGetFSDataInputStreamWhenGetSchemeIsUnimplemented(@TempDir
File tempDir) throws IOException {
+ File file = new File(tempDir, "log.file");
+ byte[] contents = new byte[] {1, 2, 3, 4};
+ Files.write(file.toPath(), contents);
+ // newInstanceLocal rather than getLocal, so closing this does not evict a
cached FileSystem that
+ // other tests in the same JVM share.
+ try (FileSystem fs = new FilterFileSystem(FileSystem.newInstanceLocal(new
Configuration()))) {
+ // The premise: this is the call the read path used to make unguarded.
+ assertThrows(UnsupportedOperationException.class, fs::getScheme);
+
+ try (FSDataInputStream stream =
+ HadoopFSUtils.getFSDataInputStream(fs, new
StoragePath(file.toURI()), 1024, true)) {
+ byte[] read = new byte[contents.length];
+ stream.readFully(read);
+ assertArrayEquals(contents, read, "The read path should not depend on
the optional getScheme()");
+ }
+ }
+ }
+
+ @Test
+ public void testGetSchemeFallsBackToTheUriWhenUnimplemented() throws
IOException {
+ try (FileSystem localFs = FileSystem.newInstanceLocal(new
Configuration())) {
+ assertEquals("file", HadoopFSUtils.getScheme(localFs),
+ "LocalFileSystem overrides getScheme(), so the helper should return
what it reports "
+ + "rather than falling back to getUri()");
+
+ try (FileSystem noScheme = new FilterFileSystem(localFs)) {
+ assertThrows(UnsupportedOperationException.class, noScheme::getScheme);
+ assertEquals("file", HadoopFSUtils.getScheme(noScheme),
+ "FilterFileSystem does not override getScheme(), so the helper
should fall back to "
+ + "getUri().getScheme()");
+ }
Review Comment:
nit, feel free to ignore: `FilterFileSystem.close()` is `super.close();
fs.close();`, so this inner block already closes `localFs` and the outer block
then closes it a second time. Harmless for `newInstanceLocal` (I checked -- the
second close does not throw and the cache key is unique), but it reads as
though the wrapper owns a resource of its own, which undercuts the accurate
`newInstanceLocal` comment at `:68-69`. The wrapper owns nothing, so it does
not need the block:
```suggestion
FileSystem noScheme = new FilterFileSystem(localFs);
assertThrows(UnsupportedOperationException.class, noScheme::getScheme);
assertEquals("file", HadoopFSUtils.getScheme(noScheme),
"FilterFileSystem does not override getScheme(), so the helper
should fall back to "
+ "getUri().getScheme()");
```
##########
hudi-hadoop-common/src/main/java/org/apache/hudi/hadoop/fs/HadoopFSUtils.java:
##########
@@ -294,7 +315,7 @@ private static StorageConfiguration<Configuration>
getStorageConf(Configuration
public static Configuration registerFileSystem(StoragePath file,
Configuration conf) {
Configuration returnConf = new Configuration(conf);
- String scheme = HadoopFSUtils.getFs(file.toString(), conf).getScheme();
+ String scheme = getScheme(HadoopFSUtils.getFs(file.toString(), conf));
Review Comment:
**This call site, `HoodieWrapperFileSystem#convertToHoodiePath` and
`HoodieHadoopStorage#getScheme` are three live behaviour changes with zero test
coverage anywhere in the repo.**
- `grep -rn "registerFileSystem\|convertToHoodiePath" --include='*.java' |
grep src/test` returns nothing.
- `TestHoodieStorageBase.java:103` (`assertEquals("file",
getStorage().getScheme())`, inherited by `TestHoodieHadoopStorage`) runs on a
`LocalFileSystem`, which *does* implement `getScheme()` -- byte-identical pre-
and post-PR.
A/B with a `LocalFileSystem` subclass whose `getScheme()` throws, registered
via `conf.setClass("fs.file.impl", ...)`: all three threw
`UnsupportedOperationException` pre-PR and all three pass post-PR. So the
behaviour is real and nothing pins it.
Weight: `convertToHoodiePath` is the **write** path (`HoodieAvroOrcWriter`,
`HoodieAvroHFileWriter`, `HoodieBaseParquetWriter`) and feeds
`convertPathWithScheme`, which needed its own fix in HUDI-4495 (`c39e88dcf0c1`,
#6237) for dotted S3 bucket names -- the same shape a Presto-on-S3 user hits.
Please add one fixture to `TestHadoopFSUtils` and assert all three:
```java
/** A FileSystem with the PrestoS3FileSystem shape: getUri() works,
getScheme() does not. */
private static class NoSchemeLocalFileSystem extends LocalFileSystem {
@Override
public String getScheme() {
throw new UnsupportedOperationException("Not implemented by the
NoSchemeLocalFileSystem FileSystem implementation");
}
}
```
Register it with `conf.setClass("fs.file.impl",
NoSchemeLocalFileSystem.class, FileSystem.class)`, then assert that
`HadoopFSUtils.registerFileSystem(...)`,
`HoodieWrapperFileSystem.convertToHoodiePath(...)` and `new
HoodieHadoopStorage(path, conf).getScheme()` all succeed. One fixture, three
uncovered sites.
##########
hudi-hadoop-common/src/test/java/org/apache/hudi/hadoop/fs/TestHadoopFSUtils.java:
##########
@@ -22,22 +22,80 @@
import org.apache.hudi.storage.StoragePath;
import org.apache.hudi.storage.StoragePathInfo;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.FilterFileSystem;
import org.apache.hadoop.fs.Path;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+
import static
org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToHadoopFileStatus;
import static org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToHadoopPath;
import static org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToStoragePath;
import static org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToStoragePathInfo;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* Tests {@link HadoopFSUtils}
*/
public class TestHadoopFSUtils {
+ /**
+ * HUDI-4602: {@link FileSystem#getScheme()} is optional in Hadoop -- the
base implementation throws
+ * {@link UnsupportedOperationException} -- and proxy implementations such
as Presto's
+ * {@code PrestoS3FileSystem} do not override it. Opening a log file went
straight through
+ * {@code isGCSFileSystem}, so a MOR {@code _rt} query on Presto failed with
+ * "Not implemented by the PrestoS3FileSystem FileSystem implementation"
rather than reading anything.
+ *
+ * <p>{@link FilterFileSystem} has the same shape: it leaves {@code
getScheme()} to the throwing base
+ * implementation while overriding {@code getUri()}.
+ */
+ @Test
+ public void testGetFSDataInputStreamWhenGetSchemeIsUnimplemented(@TempDir
File tempDir) throws IOException {
Review Comment:
nit, feel free to ignore: `@TempDir File` is against this module's
convention -- `grep -rn "@TempDir File" --include='*.java'` finds only this and
two in `hudi-flink-datasource`, while every `@TempDir` in `hudi-hadoop-common`
uses `java.nio.file.Path` (`TestTimelineInspector.java:89`,
`TestHoodieVariantReconstruction.java:55`, `TestHoodieLogFormat.java:446`). The
test also converts straight back with `file.toPath()` on the next line.
Switching drops the `java.io.File` import:
```java
public void testGetFSDataInputStreamWhenGetSchemeIsUnimplemented(@TempDir
Path tempDir) throws IOException {
Path file = tempDir.resolve("log.file");
byte[] contents = new byte[] {1, 2, 3, 4};
Files.write(file, contents);
```
Note this also needs `file.toURI()` on `:75` changed to `file.toUri()`, so
it is not a one-click apply.
##########
hudi-hadoop-common/src/main/java/org/apache/hudi/hadoop/fs/HadoopFSUtils.java:
##########
@@ -277,15 +277,36 @@ private static FSDataInputStream
getFSDataInputStreamForGCS(FSDataInputStream fs
* @return true if the inputstream or the wrapped one is of type
GoogleHadoopFSInputStream
*/
public static boolean isGCSFileSystem(FileSystem fs) {
- return fs.getScheme().equals(StorageSchemes.GCS.getScheme());
+ return StorageSchemes.GCS.getScheme().equals(getScheme(fs));
Review Comment:
**This predicate and `isCHDFileSystem` become reachable for proxy
filesystems for the first time with this PR, and neither they nor the two
stream classes they select have ever had a test.**
- `grep -rn
"isGCSFileSystem\|isCHDFileSystem\|SchemeAwareFSDataInputStream\|BoundedFsDataInputStream"
--include='*.java'` returns zero hits in the test tree.
- `testGetFSDataInputStreamWhenGetSchemeIsUnimplemented` uses `file://`, so
both predicates return `false` and only the fall-through arm at the bottom of
`getFSDataInputStream` runs.
A/B with a scheme-less FS reporting `gs://bucket` and `ofs://cluster`:
pre-PR both throw `UnsupportedOperationException`; post-PR they return
`SchemeAwareFSDataInputStream` and `BoundedFsDataInputStream` respectively.
That is new reachable behaviour, and it is exactly the code with a bug history:
- `e93c6a569310` (HUDI-1496, #2500) *is a fix to `isGCSFileSystem` itself*
-- it replaced stream-instanceof detection with this scheme equality, i.e. the
predicate you are re-plumbing.
- `eaa2f8ed3bb3` (HUDI-4282, #6031) added the CHDFS arm.
Neither shipped a unit test. Please extend the fixture from my
`registerFileSystem` comment with `getUri()` overridden to `gs://bucket` and
`ofs://cluster`, and assert `getFSDataInputStream(...)` returns
`SchemeAwareFSDataInputStream` / `BoundedFsDataInputStream`. This is the only
assertion in the PR that would catch a future regression where
`HadoopFSUtils.getScheme` returns something other than what `fs.getScheme()`
would have.
##########
hudi-hadoop-common/src/test/java/org/apache/hudi/hadoop/fs/TestHadoopFSUtils.java:
##########
@@ -22,22 +22,80 @@
import org.apache.hudi.storage.StoragePath;
import org.apache.hudi.storage.StoragePathInfo;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.FilterFileSystem;
import org.apache.hadoop.fs.Path;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+
import static
org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToHadoopFileStatus;
import static org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToHadoopPath;
import static org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToStoragePath;
import static org.apache.hudi.hadoop.fs.HadoopFSUtils.convertToStoragePathInfo;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* Tests {@link HadoopFSUtils}
*/
public class TestHadoopFSUtils {
+ /**
+ * HUDI-4602: {@link FileSystem#getScheme()} is optional in Hadoop -- the
base implementation throws
+ * {@link UnsupportedOperationException} -- and proxy implementations such
as Presto's
+ * {@code PrestoS3FileSystem} do not override it. Opening a log file went
straight through
+ * {@code isGCSFileSystem}, so a MOR {@code _rt} query on Presto failed with
+ * "Not implemented by the PrestoS3FileSystem FileSystem implementation"
rather than reading anything.
+ *
+ * <p>{@link FilterFileSystem} has the same shape: it leaves {@code
getScheme()} to the throwing base
+ * implementation while overriding {@code getUri()}.
+ */
+ @Test
+ public void testGetFSDataInputStreamWhenGetSchemeIsUnimplemented(@TempDir
File tempDir) throws IOException {
+ File file = new File(tempDir, "log.file");
+ byte[] contents = new byte[] {1, 2, 3, 4};
+ Files.write(file.toPath(), contents);
+ // newInstanceLocal rather than getLocal, so closing this does not evict a
cached FileSystem that
+ // other tests in the same JVM share.
+ try (FileSystem fs = new FilterFileSystem(FileSystem.newInstanceLocal(new
Configuration()))) {
Review Comment:
nit, feel free to ignore: this fixture and the premise assertion on the next
line are copy-pasted into `testGetSchemeFallsBackToTheUriWhenUnimplemented`
(`:90-91`). Please extract them once:
```java
/** A FileSystem with the reported shape: getUri() works, getScheme()
throws. */
private static FileSystem newFsWithoutGetScheme(FileSystem delegate) {
FileSystem fs = new FilterFileSystem(delegate);
assertThrows(UnsupportedOperationException.class, fs::getScheme);
return fs;
}
```
##########
hudi-hadoop-common/src/main/java/org/apache/hudi/hadoop/fs/HadoopFSUtils.java:
##########
@@ -277,15 +277,36 @@ private static FSDataInputStream
getFSDataInputStreamForGCS(FSDataInputStream fs
* @return true if the inputstream or the wrapped one is of type
GoogleHadoopFSInputStream
*/
public static boolean isGCSFileSystem(FileSystem fs) {
- return fs.getScheme().equals(StorageSchemes.GCS.getScheme());
+ return StorageSchemes.GCS.getScheme().equals(getScheme(fs));
}
/**
* Chdfs will throw {@code IOException} instead of {@code EOFException}. It
will cause error in isBlockCorrupted().
* Wrapped by {@code BoundedFsDataInputStream}, to check whether the desired
offset is out of the file size in advance.
*/
public static boolean isCHDFileSystem(FileSystem fs) {
- return StorageSchemes.CHDFS.getScheme().equals(fs.getScheme());
+ return StorageSchemes.CHDFS.getScheme().equals(getScheme(fs));
+ }
+
+ /**
+ * Resolves the scheme of {@code fs} without depending on {@link
FileSystem#getScheme()}.
+ *
+ * <p>{@code getScheme()} is optional in Hadoop: {@link FileSystem}'s own
implementation throws
+ * {@link UnsupportedOperationException}, and proxy implementations such as
Presto's
+ * {@code PrestoS3FileSystem} do not override it, so calling it unguarded
turns an unrelated read into
+ * "Not implemented by the PrestoS3FileSystem FileSystem implementation"
(HUDI-4602).
+ * {@link FileSystem#getUri()} is abstract, so every implementation supplies
it, and its scheme is what
+ * {@code getScheme()} returns wherever both are present.
+ *
+ * @param fs instance of {@link FileSystem} in use.
+ * @return the scheme of {@code fs}, or null if its URI carries none.
+ */
+ public static String getScheme(FileSystem fs) {
+ try {
+ return fs.getScheme();
+ } catch (UnsupportedOperationException e) {
+ return fs.getUri().getScheme();
+ }
Review Comment:
**The fallback discards the root cause and can return `null`, and the
javadoc's equivalence claim is falsified by a class in this same module.**
`InLineFileSystem` has both methods and they disagree
(`InLineFileSystem.java:86-92`):
```java
public URI getUri() { return URI.create(getScheme()); } //
URI.create("inlinefs") -> getScheme() is null
public String getScheme() { return SCHEME; } // "inlinefs"
```
`"inlinefs"` has no colon, so it parses as a relative URI and
`URI#getScheme()` returns `null`. So line 298-299 ("its scheme is what
`getScheme()` returns wherever both are present") is not true, and the ordering
here is load-bearing rather than cosmetic.
When the fallback does yield `null`, it surfaces far from the cause with
nonsense text -- `IllegalArgumentException: BlockAlignedAvroParquetWriter does
not support scheme null` from `HoodieWrapperFileSystem#getHoodieScheme`, or
`Unsupported scheme :null` from `StorageSchemes:137-158` -- and the original
`"Not implemented by the PrestoS3FileSystem FileSystem implementation"` is
thrown away. Same if `fs.getUri()` itself throws.
Please fail loudly and chain the cause (`HoodieIOException` is already
imported, so this applies as-is):
```suggestion
try {
return fs.getScheme();
} catch (UnsupportedOperationException e) {
String scheme = fs.getUri().getScheme();
if (scheme == null) {
throw new HoodieIOException("Cannot resolve the scheme of " +
fs.getClass().getName()
+ ": getScheme() is unimplemented and its URI " + fs.getUri() +
" carries no scheme", e);
}
return scheme;
}
```
and drop the "its scheme is what `getScheme()` returns wherever both are
present" sentence (298-299) plus the "or null if its URI carries none" clause
on `@return` (302), since neither would hold any more.
##########
hudi-hadoop-common/src/main/java/org/apache/hudi/hadoop/fs/HoodieWrapperFileSystem.java:
##########
@@ -160,7 +160,7 @@ public HoodieWrapperFileSystem(FileSystem fileSystem,
ConsistencyGuard consisten
public static Path convertToHoodiePath(StoragePath file, Configuration conf)
{
try {
- String scheme = HadoopFSUtils.getFs(file.toString(), conf).getScheme();
+ String scheme =
HadoopFSUtils.getScheme(HadoopFSUtils.getFs(file.toString(), conf));
Review Comment:
nit, feel free to ignore: while you are in this method, the `try` wrapping
it only catches `HoodieIOException` to rethrow it unchanged (`161-167`), which
is a no-op. Dead since `ef70de2bba7b`. Please drop the `try`/`catch` and leave
the two statements bare:
```java
public static Path convertToHoodiePath(StoragePath file, Configuration
conf) {
String scheme =
HadoopFSUtils.getScheme(HadoopFSUtils.getFs(file.toString(), conf));
return convertPathWithScheme(convertToHadoopPath(file),
getHoodieScheme(scheme));
}
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
