| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.event; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader; |
| |
| |
| |
| |
| @@ -1,23 +1,24 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader; |
| |
| +import org.apache.flink.api.connector.source.ReaderOutput; |
| import org.apache.flink.api.connector.source.SourceEvent; |
| import org.apache.flink.api.connector.source.SourceOutput; |
| import org.apache.flink.api.connector.source.SourceReader; |
| @@ -63,7 +64,7 @@ public abstract class SourceReaderBase<E, T, SplitT extends SourceSplit, SplitSt |
| private final BlockingQueue<RecordsWithSplitIds<E>> elementsQueue; |
| |
| /** The state of the splits. */ |
| - private final Map<String, SplitStateT> splitStates; |
| + private final Map<String, SplitContext<T, SplitStateT>> splitStates; |
| |
| /** The record emitter to handle the records read by the SplitReaders. */ |
| protected final RecordEmitter<E, T, SplitStateT> recordEmitter; |
| @@ -111,7 +112,7 @@ public abstract class SourceReaderBase<E, T, SplitT extends SourceSplit, SplitSt |
| } |
| |
| @Override |
| - public InputStatus pollNext(SourceOutput<T> sourceOutput) throws Exception { |
| + public InputStatus pollNext(ReaderOutput<T> output) throws Exception { |
| splitFetcherManager.checkErrors(); |
| // poll from the queue if the last element was successfully handled. Otherwise |
| // just pass the last element again. |
| @@ -133,14 +134,19 @@ public abstract class SourceReaderBase<E, T, SplitT extends SourceSplit, SplitSt |
| // Process one record. |
| if (splitIter.hasNext()) { |
| // emit the record. |
| - E record = splitIter.next(); |
| - recordEmitter.emitRecord(record, sourceOutput, splitStates.get(splitIter.currentSplitId())); |
| + final E record = splitIter.next(); |
| + final SplitContext<T, SplitStateT> splitContext = splitStates.get(splitIter.currentSplitId()); |
| + final SourceOutput<T> splitOutput = splitContext.getOrCreateSplitOutput(output); |
| + recordEmitter.emitRecord(record, splitOutput, splitContext.state); |
| LOG.trace("Emitted record: {}", record); |
| } |
| // Do some cleanup if the all the records in the current splitIter have been processed. |
| if (!splitIter.hasNext()) { |
| // First remove the state of the split. |
| - splitIter.finishedSplitIds().forEach(splitStates::remove); |
| + splitIter.finishedSplitIds().forEach((id) -> { |
| + splitStates.remove(id); |
| + output.releaseOutputForSplit(id); |
| + }); |
| // Handle the finished splits. |
| onSplitFinished(splitIter.finishedSplitIds()); |
| // Prepare the return status based on the availability of the next element. |
| @@ -173,7 +179,7 @@ public abstract class SourceReaderBase<E, T, SplitT extends SourceSplit, SplitSt |
| @Override |
| public List<SplitT> snapshotState() { |
| List<SplitT> splits = new ArrayList<>(); |
| - splitStates.forEach((id, state) -> splits.add(toSplitType(id, state))); |
| + splitStates.forEach((id, context) -> splits.add(toSplitType(id, context.state))); |
| return splits; |
| } |
| |
| @@ -181,7 +187,7 @@ public abstract class SourceReaderBase<E, T, SplitT extends SourceSplit, SplitSt |
| public void addSplits(List<SplitT> splits) { |
| LOG.trace("Adding splits {}", splits); |
| // Initialize the state for each split. |
| - splits.forEach(s -> splitStates.put(s.splitId(), initializedState(s))); |
| + splits.forEach(s -> splitStates.put(s.splitId(), new SplitContext<>(s.splitId(), initializedState(s)))); |
| // Hand over the splits to the split fetcher to start fetch. |
| splitFetcherManager.addSplits(splits); |
| } |
| @@ -201,6 +207,8 @@ public abstract class SourceReaderBase<E, T, SplitT extends SourceSplit, SplitSt |
| splitFetcherManager.close(options.sourceReaderCloseTimeout); |
| } |
| |
| + |
| + |
| // -------------------- Abstract method to allow different implementations ------------------ |
| /** |
| * Handles the finished splits to clean the state if needed. |
| @@ -233,4 +241,25 @@ public abstract class SourceReaderBase<E, T, SplitT extends SourceSplit, SplitSt |
| return InputStatus.NOTHING_AVAILABLE; |
| } |
| } |
| + |
| + // ------------------ private helper classes --------------------- |
| + |
| + private static final class SplitContext<T, SplitStateT> { |
| + |
| + final String splitId; |
| + final SplitStateT state; |
| + SourceOutput<T> sourceOutput; |
| + |
| + private SplitContext(String splitId, SplitStateT state) { |
| + this.state = state; |
| + this.splitId = splitId; |
| + } |
| + |
| + SourceOutput<T> getOrCreateSplitOutput(ReaderOutput<T> mainOutput) { |
| + if (sourceOutput == null) { |
| + sourceOutput = mainOutput.createOutputForSplit(splitId); |
| + } |
| + return sourceOutput; |
| + } |
| + } |
| } |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.fetcher; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.fetcher; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.fetcher; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.fetcher; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.fetcher; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.fetcher; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.splitreader; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.splitreader; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.splitreader; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.synchronization; |
| |
| |
| |
| |
| @@ -1,19 +1,19 @@ |
| /* |
| - 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. |
| + * 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.flink.connector.base.source.reader.synchronization; |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,34 @@ |
| +/* |
| + * 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.flink.api.common.eventtime; |
| + |
| +import org.apache.flink.annotation.Public; |
| + |
| +/** |
| + * An implementation of a {@link WatermarkGenerator} that generates no Watermarks. |
| + */ |
| +@Public |
| +public final class NoWatermarksGenerator<E> implements WatermarkGenerator<E> { |
| + |
| + @Override |
| + public void onEvent(E event, long eventTimestamp, WatermarkOutput output) {} |
| + |
| + @Override |
| + public void onPeriodicEmit(WatermarkOutput output) {} |
| +} |
| |
| |
| |
| |
| @@ -35,13 +35,20 @@ import org.apache.flink.annotation.Public; |
| @FunctionalInterface |
| public interface TimestampAssigner<T> { |
| |
| + /** |
| + * The value that is passed to {@link #extractTimestamp} when there is no previous timestamp |
| + * attached to the record. |
| + */ |
| + long NO_TIMESTAMP = Long.MIN_VALUE; |
| + |
| /** |
| * Assigns a timestamp to an element, in milliseconds since the Epoch. This is independent of |
| * any particular time zone or calendar. |
| * |
| * <p>The method is passed the previously assigned timestamp of the element. |
| * That previous timestamp may have been assigned from a previous assigner. If the element did |
| - * not carry a timestamp before, this value is {@code Long.MIN_VALUE}. |
| + * not carry a timestamp before, this value is {@link #NO_TIMESTAMP} (= {@code Long.MIN_VALUE}: |
| + * {@value Long#MIN_VALUE}). |
| * |
| * @param element The element that the timestamp will be assigned to. |
| * @param recordTimestamp The current internal timestamp of the element, |
| |
| |
| |
| |
| @@ -40,8 +40,8 @@ import static org.apache.flink.util.Preconditions.checkState; |
| * #onPeriodicEmit()} is called will the deferred updates be combined and forwarded to the |
| * underlying output. |
| * |
| - * <p>For registering a new multiplexed output, you must first call {@link #registerNewOutput()} |
| - * and then call {@link #getImmediateOutput(int)} or {@link #getDeferredOutput(int)} with the output |
| + * <p>For registering a new multiplexed output, you must first call {@link #registerNewOutput(String)} |
| + * and then call {@link #getImmediateOutput(String)} or {@link #getDeferredOutput(String)} with the output |
| * ID you get from that. You can get both an immediate and deferred output for a given output ID, |
| * you can also call the getters multiple times. |
| * |
| @@ -57,16 +57,13 @@ public class WatermarkOutputMultiplexer { |
| */ |
| private final WatermarkOutput underlyingOutput; |
| |
| - /** The id to use for the next registered output. */ |
| - private int nextOutputId = 0; |
| - |
| /** The combined watermark over the per-output watermarks. */ |
| private long combinedWatermark = Long.MIN_VALUE; |
| |
| /** |
| * Map view, to allow finding them when requesting the {@link WatermarkOutput} for a given id. |
| */ |
| - private final Map<Integer, OutputState> watermarkPerOutputId; |
| + private final Map<String, OutputState> watermarkPerOutputId; |
| |
| /** |
| * List of all watermark outputs, for efficient access. |
| @@ -88,13 +85,23 @@ public class WatermarkOutputMultiplexer { |
| * an output ID that can be used to get a deferred or immediate {@link WatermarkOutput} for that |
| * output. |
| */ |
| - public int registerNewOutput() { |
| - int newOutputId = nextOutputId; |
| - nextOutputId++; |
| - OutputState outputState = new OutputState(); |
| - watermarkPerOutputId.put(newOutputId, outputState); |
| + public void registerNewOutput(String id) { |
| + final OutputState outputState = new OutputState(); |
| + |
| + final OutputState previouslyRegistered = watermarkPerOutputId.putIfAbsent(id, outputState); |
| + checkState(previouslyRegistered == null, "Already contains an output for ID %s", id); |
| + |
| watermarkOutputs.add(outputState); |
| - return newOutputId; |
| + } |
| + |
| + public boolean unregisterOutput(String id) { |
| + final OutputState output = watermarkPerOutputId.remove(id); |
| + if (output != null) { |
| + watermarkOutputs.remove(output); |
| + return true; |
| + } else { |
| + return false; |
| + } |
| } |
| |
| /** |
| @@ -103,12 +110,9 @@ public class WatermarkOutputMultiplexer { |
| * <p>>See {@link WatermarkOutputMultiplexer} for a description of immediate and deferred |
| * outputs. |
| */ |
| - public WatermarkOutput getImmediateOutput(int outputId) { |
| - Preconditions.checkArgument( |
| - watermarkPerOutputId.containsKey(outputId), |
| - "no output registered under id " + outputId); |
| - |
| - OutputState outputState = watermarkPerOutputId.get(outputId); |
| + public WatermarkOutput getImmediateOutput(String outputId) { |
| + final OutputState outputState = watermarkPerOutputId.get(outputId); |
| + Preconditions.checkArgument(outputState != null, "no output registered under id %s", outputId); |
| return new ImmediateOutput(outputState); |
| } |
| |
| @@ -118,12 +122,9 @@ public class WatermarkOutputMultiplexer { |
| * <p>>See {@link WatermarkOutputMultiplexer} for a description of immediate and deferred |
| * outputs. |
| */ |
| - public WatermarkOutput getDeferredOutput(int outputId) { |
| - Preconditions.checkArgument( |
| - watermarkPerOutputId.containsKey(outputId), |
| - "no output registered under id " + outputId); |
| - |
| - OutputState outputState = watermarkPerOutputId.get(outputId); |
| + public WatermarkOutput getDeferredOutput(String outputId) { |
| + final OutputState outputState = watermarkPerOutputId.get(outputId); |
| + Preconditions.checkArgument(outputState != null, "no output registered under id %s", outputId); |
| return new DeferredOutput(outputState); |
| } |
| |
| @@ -171,8 +172,8 @@ public class WatermarkOutputMultiplexer { |
| * Per-output watermark state. |
| */ |
| private static class OutputState { |
| - private volatile long watermark = Long.MIN_VALUE; |
| - private volatile boolean idle = false; |
| + private long watermark = Long.MIN_VALUE; |
| + private boolean idle = false; |
| |
| /** |
| * Returns the current watermark timestamp. This will throw {@link IllegalStateException} if |
| @@ -191,12 +192,9 @@ public class WatermarkOutputMultiplexer { |
| */ |
| public boolean setWatermark(long watermark) { |
| this.idle = false; |
| - if (watermark > this.watermark) { |
| - this.watermark = watermark; |
| - return true; |
| - } else { |
| - return false; |
| - } |
| + final boolean updated = watermark > this.watermark; |
| + this.watermark = Math.max(watermark, this.watermark); |
| + return updated; |
| } |
| |
| public boolean isIdle() { |
| |
| |
| |
| |
| @@ -175,6 +175,14 @@ public final class WatermarkStrategies<T> { |
| return new WatermarkStrategies<>(new FromWatermarkGeneratorSupplier<>(generatorSupplier)); |
| } |
| |
| + /** |
| + * Starts building a watermark strategy that generates no watermarks at all. |
| + * This may be useful in scenarios that do pure processing-time based stream processing. |
| + */ |
| + public static <T> WatermarkStrategies<T> noWatermarks() { |
| + return new WatermarkStrategies<>((ctx) -> new NoWatermarksGenerator<>()); |
| + } |
| + |
| // ------------------------------------------------------------------------ |
| |
| private static final class FromWatermarkGeneratorSupplier<T> implements WatermarkStrategy<T> { |
| |
| |
| |
| |
| @@ -31,7 +31,7 @@ import java.io.Serializable; |
| * to workers during distributed execution. |
| */ |
| @Public |
| -public interface WatermarkStrategy<T> extends TimestampAssignerSupplier<T>, WatermarkGeneratorSupplier<T>{ |
| +public interface WatermarkStrategy<T> extends TimestampAssignerSupplier<T>, WatermarkGeneratorSupplier<T> { |
| |
| /** |
| * Instantiates a {@link TimestampAssigner} for assigning timestamps according to this |
| |
| |
| |
| |
| @@ -1,30 +1,30 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| |
| /** |
| * The boundedness of a stream. A stream could either be "bounded" (a stream with finite records) or |
| * "unbounded" (a stream with infinite records). |
| */ |
| -@Public |
| +@PublicEvolving |
| public enum Boundedness { |
| /** |
| * A BOUNDED stream is a stream with finite records. |
| |
| |
| |
| |
| @@ -1,24 +1,24 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| |
| import java.io.Serializable; |
| import java.util.Objects; |
| @@ -26,7 +26,7 @@ import java.util.Objects; |
| /** |
| * A container class hosting the information of a {@link SourceReader}. |
| */ |
| -@Public |
| +@PublicEvolving |
| public final class ReaderInfo implements Serializable { |
| |
| private static final long serialVersionUID = 1L; |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,117 @@ |
| +/* |
| + * 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.flink.api.connector.source; |
| + |
| +import org.apache.flink.annotation.PublicEvolving; |
| +import org.apache.flink.api.common.eventtime.TimestampAssigner; |
| +import org.apache.flink.api.common.eventtime.Watermark; |
| + |
| +/** |
| + * The interface provided by the Flink runtime to the {@link SourceReader} to emit records, and |
| + * optionally watermarks, to downstream operators for message processing. |
| + * |
| + * <p>The {@code ReaderOutput} is a {@link SourceOutput} and can be used directly to emit the stream |
| + * of events from the source. This is recommended for source where the SourceReader processes only a |
| + * single split, or where NO split-specific characteristics are required (like per-split watermarks |
| + * and idleness, split-specific event-time skew handling, etc.). |
| + * As a special case, this is true for sources that are purely supporting bounded/batch data processing. |
| + * |
| + * <p>For most streaming sources, the {@code SourceReader} should use split-specific outputs, to allow |
| + * the processing logic to run per-split watermark generators, idleness detection, etc. |
| + * To create a split-specific {@code SourceOutput} use the {@link ReaderOutput#createOutputForSplit(String)} |
| + * method, using the Source Split's ID. Make sure to release the output again once the source has finished |
| + * processing that split. |
| + */ |
| +@PublicEvolving |
| +public interface ReaderOutput<T> extends SourceOutput<T> { |
| + |
| + /** |
| + * Emit a record without a timestamp. |
| + * |
| + * <p>Use this method if the source system does not have a notion of records with timestamps. |
| + * |
| + * <p>The events later pass through a {@link TimestampAssigner}, which attaches a timestamp |
| + * to the event based on the event's contents. For example a file source with JSON records would not |
| + * have a generic timestamp from the file reading and JSON parsing process, and thus use this |
| + * method to produce initially a record without a timestamp. The {@code TimestampAssigner} in |
| + * the next step would be used to extract timestamp from a field of the JSON object. |
| + * |
| + * @param record the record to emit. |
| + */ |
| + @Override |
| + void collect(T record); |
| + |
| + /** |
| + * Emit a record with a timestamp. |
| + * |
| + * <p>Use this method if the source system has timestamps attached to records. Typical examples |
| + * would be Logs, PubSubs, or Message Queues, like Kafka or Kinesis, which store a timestamp with |
| + * each event. |
| + * |
| + * <p>The events typically still pass through a {@link TimestampAssigner}, which may decide to |
| + * either use this source-provided timestamp, or replace it with a timestamp stored within the |
| + * event (for example if the event was a JSON object one could configure aTimestampAssigner that |
| + * extracts one of the object's fields and uses that as a timestamp). |
| + * |
| + * @param record the record to emit. |
| + * @param timestamp the timestamp of the record. |
| + */ |
| + @Override |
| + void collect(T record, long timestamp); |
| + |
| + /** |
| + * Emits the given watermark. |
| + * |
| + * <p>Emitting a watermark also implicitly marks the stream as <i>active</i>, ending |
| + * previously marked idleness. |
| + */ |
| + @Override |
| + void emitWatermark(Watermark watermark); |
| + |
| + /** |
| + * Marks this output as idle, meaning that downstream operations do not |
| + * wait for watermarks from this output. |
| + * |
| + * <p>An output becomes active again as soon as the next watermark is emitted. |
| + */ |
| + @Override |
| + void markIdle(); |
| + |
| + /** |
| + * Creates a {@code SourceOutput} for a specific Source Split. Use these outputs if you want to |
| + * run split-local logic, like watermark generation. |
| + * |
| + * <p>If a split-local output was already created for this split-ID, the method will return that instance, |
| + * so that only one split-local output exists per split-ID. |
| + * |
| + * <p><b>IMPORTANT:</b> After the split has been finished, it is crucial to release the created |
| + * output again. Otherwise it will continue to contribute to the watermark generation like a |
| + * perpetually stalling source split, and may hold back the watermark indefinitely. |
| + * |
| + * @see #releaseOutputForSplit(String) |
| + */ |
| + SourceOutput<T> createOutputForSplit(String splitId); |
| + |
| + /** |
| + * Releases the {@code SourceOutput} created for the split with the given ID. |
| + * |
| + * @see #createOutputForSplit(String) |
| + */ |
| + void releaseOutputForSplit(String splitId); |
| +} |
| |
| |
| |
| |
| @@ -1,24 +1,24 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| import org.apache.flink.core.io.SimpleVersionedSerializer; |
| |
| import java.io.IOException; |
| @@ -33,7 +33,7 @@ import java.io.Serializable; |
| * @param <SplitT> The type of splits handled by the source. |
| * @param <EnumChkT> The type of the enumerator checkpoints. |
| */ |
| -@Public |
| +@PublicEvolving |
| public interface Source<T, SplitT extends SourceSplit, EnumChkT> extends Serializable { |
| |
| /** |
| |
| |
| |
| |
| @@ -1,31 +1,31 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| |
| import java.io.Serializable; |
| |
| /** |
| * An base class for the events passed between the SourceReaders and Enumerators. |
| */ |
| -@Public |
| +@PublicEvolving |
| public interface SourceEvent extends Serializable { |
| |
| } |
| |
| |
| |
| |
| @@ -1,45 +1,67 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| +import org.apache.flink.api.common.eventtime.TimestampAssigner; |
| import org.apache.flink.api.common.eventtime.WatermarkOutput; |
| |
| /** |
| - * The interface provided by Flink task to the {@link SourceReader} to emit records |
| - * to downstream operators for message processing. |
| + * The {@code SourceOutput} is the gateway for a {@link SourceReader}) to emit the produced |
| + * records and watermarks. |
| + * |
| + * <p>A {@code SourceReader} may have multiple SourceOutputs, scoped to individual <i>Source Splits</i>. That |
| + * way, streams of events from different splits can be identified and treated separately, for example |
| + * for watermark generation, or event-time skew handling. |
| */ |
| -@Public |
| +@PublicEvolving |
| public interface SourceOutput<T> extends WatermarkOutput { |
| |
| /** |
| - * Emit a record without a timestamp. Equivalent to {@link #collect(Object, long) collect(timestamp, null)}; |
| + * Emit a record without a timestamp. |
| + * |
| + * <p>Use this method if the source system does not have a notion of records with timestamps. |
| + * |
| + * <p>The events later pass through a {@link TimestampAssigner}, which attaches a timestamp |
| + * to the event based on the event's contents. For example a file source with JSON records would not |
| + * have a generic timestamp from the file reading and JSON parsing process, and thus use this |
| + * method to produce initially a record without a timestamp. The {@code TimestampAssigner} in |
| + * the next step would be used to extract timestamp from a field of the JSON object. |
| * |
| * @param record the record to emit. |
| */ |
| - void collect(T record) throws Exception; |
| + void collect(T record); |
| |
| /** |
| - * Emit a record with timestamp. |
| + * Emit a record with a timestamp. |
| + * |
| + * <p>Use this method if the source system has timestamps attached to records. Typical examples |
| + * would be Logs, PubSubs, or Message Queues, like Kafka or Kinesis, which store a timestamp with |
| + * each event. |
| + * |
| + * <p>The events typically still pass through a {@link TimestampAssigner}, which may decide to |
| + * either use this source-provided timestamp, or replace it with a timestamp stored within the |
| + * event (for example if the event was a JSON object one could configure aTimestampAssigner that |
| + * extracts one of the object's fields and uses that as a timestamp). |
| * |
| * @param record the record to emit. |
| * @param timestamp the timestamp of the record. |
| */ |
| - void collect(T record, long timestamp) throws Exception; |
| + void collect(T record, long timestamp); |
| } |
| |
| |
| |
| |
| @@ -1,24 +1,24 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| import org.apache.flink.core.io.InputStatus; |
| |
| import java.util.List; |
| @@ -31,7 +31,7 @@ import java.util.concurrent.CompletableFuture; |
| * @param <T> The type of the record emitted by this source reader. |
| * @param <SplitT> The type of the the source splits. |
| */ |
| -@Public |
| +@PublicEvolving |
| public interface SourceReader<T, SplitT extends SourceSplit> extends AutoCloseable { |
| |
| /** |
| @@ -51,7 +51,7 @@ public interface SourceReader<T, SplitT extends SourceSplit> extends AutoCloseab |
| * |
| * @return The InputStatus of the SourceReader after the method invocation. |
| */ |
| - InputStatus pollNext(SourceOutput<T> sourceOutput) throws Exception; |
| + InputStatus pollNext(ReaderOutput<T> output) throws Exception; |
| |
| /** |
| * Checkpoint on the state of the source. |
| |
| |
| |
| |
| @@ -1,30 +1,30 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| import org.apache.flink.metrics.MetricGroup; |
| |
| /** |
| * The class that expose some context from runtime to the {@link SourceReader}. |
| */ |
| -@Public |
| +@PublicEvolving |
| public interface SourceReaderContext { |
| |
| /** |
| |
| |
| |
| |
| @@ -1,29 +1,29 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| |
| /** |
| * An interface for all the Split types to extend. |
| */ |
| -@Public |
| +@PublicEvolving |
| public interface SourceSplit { |
| |
| /** |
| |
| |
| |
| |
| @@ -1,24 +1,24 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| |
| import java.io.IOException; |
| import java.util.List; |
| @@ -28,7 +28,7 @@ import java.util.List; |
| * 1. discover the splits for the {@link SourceReader} to read. |
| * 2. assign the splits to the source reader. |
| */ |
| -@Public |
| +@PublicEvolving |
| public interface SplitEnumerator<SplitT extends SourceSplit, CheckpointT> extends AutoCloseable { |
| |
| /** |
| |
| |
| |
| |
| @@ -1,24 +1,24 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| import org.apache.flink.metrics.MetricGroup; |
| |
| import java.util.Map; |
| @@ -34,7 +34,7 @@ import java.util.function.BiConsumer; |
| * |
| * @param <SplitT> the type of the splits. |
| */ |
| -@Public |
| +@PublicEvolving |
| public interface SplitEnumeratorContext<SplitT extends SourceSplit> { |
| |
| MetricGroup metricGroup(); |
| |
| |
| |
| |
| @@ -1,24 +1,24 @@ |
| /* |
| - 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. |
| + * 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.flink.api.connector.source; |
| |
| -import org.apache.flink.annotation.Public; |
| +import org.apache.flink.annotation.PublicEvolving; |
| |
| import java.util.List; |
| import java.util.Map; |
| @@ -29,7 +29,7 @@ import java.util.Map; |
| * <p>The assignment is always incremental. In another word, splits in the assignment are simply |
| * added to the existing assignment. |
| */ |
| -@Public |
| +@PublicEvolving |
| public final class SplitsAssignment<SplitT extends SourceSplit> { |
| private final Map<Integer, List<SplitT>> assignment; |
| |
| |
| |
| |
| |
| @@ -18,6 +18,7 @@ |
| package org.apache.flink.streaming.api.datastream; |
| |
| import org.apache.flink.annotation.Public; |
| +import org.apache.flink.api.common.eventtime.WatermarkStrategy; |
| import org.apache.flink.api.common.operators.util.OperatorValidationUtils; |
| import org.apache.flink.api.common.typeinfo.TypeInformation; |
| import org.apache.flink.api.connector.source.Source; |
| @@ -37,9 +38,15 @@ public class DataStreamSource<T> extends SingleOutputStreamOperator<T> { |
| |
| boolean isParallel; |
| |
| - public DataStreamSource(StreamExecutionEnvironment environment, |
| - TypeInformation<T> outTypeInfo, StreamSource<T, ?> operator, |
| - boolean isParallel, String sourceName) { |
| + /** |
| + * The constructor used to create legacy sources. |
| + */ |
| + public DataStreamSource( |
| + StreamExecutionEnvironment environment, |
| + TypeInformation<T> outTypeInfo, |
| + StreamSource<T, ?> operator, |
| + boolean isParallel, |
| + String sourceName) { |
| super(environment, new LegacySourceTransformation<>(sourceName, operator, outTypeInfo, environment.getParallelism())); |
| |
| this.isParallel = isParallel; |
| @@ -48,20 +55,27 @@ public class DataStreamSource<T> extends SingleOutputStreamOperator<T> { |
| } |
| } |
| |
| + /** |
| + * Constructor for "deep" sources that manually set up (one or more) custom configured complex operators. |
| + */ |
| public DataStreamSource(SingleOutputStreamOperator<T> operator) { |
| super(operator.environment, operator.getTransformation()); |
| this.isParallel = true; |
| } |
| |
| + /** |
| + * Constructor for new Sources (FLIP-27). |
| + */ |
| public DataStreamSource( |
| StreamExecutionEnvironment environment, |
| Source<T, ?, ?> source, |
| + WatermarkStrategy<T> timestampsAndWatermarks, |
| TypeInformation<T> outTypeInfo, |
| String sourceName) { |
| super(environment, |
| new SourceTransformation<>( |
| sourceName, |
| - new SourceOperatorFactory<>(source), |
| + new SourceOperatorFactory<>(source, timestampsAndWatermarks), |
| outTypeInfo, |
| environment.getParallelism())); |
| } |
| |
| |
| |
| |
| @@ -55,7 +55,7 @@ public class SingleOutputStreamOperator<T> extends DataStream<T> { |
| * we can catch the case when a side output with a matching id is requested for a different |
| * type because this would lead to problems at runtime. |
| */ |
| - private Map<OutputTag<?>, TypeInformation> requestedSideOutputs = new HashMap<>(); |
| + private Map<OutputTag<?>, TypeInformation<?>> requestedSideOutputs = new HashMap<>(); |
| |
| private boolean wasSplitApplied = false; |
| |
| |
| |
| |
| |
| @@ -17,6 +17,7 @@ |
| |
| package org.apache.flink.streaming.api.environment; |
| |
| +import org.apache.flink.annotation.Experimental; |
| import org.apache.flink.annotation.Internal; |
| import org.apache.flink.annotation.Public; |
| import org.apache.flink.annotation.PublicEvolving; |
| @@ -24,6 +25,7 @@ import org.apache.flink.api.common.ExecutionConfig; |
| import org.apache.flink.api.common.InvalidProgramException; |
| import org.apache.flink.api.common.JobExecutionResult; |
| import org.apache.flink.api.common.cache.DistributedCache; |
| +import org.apache.flink.api.common.eventtime.WatermarkStrategy; |
| import org.apache.flink.api.common.functions.InvalidTypesException; |
| import org.apache.flink.api.common.io.FileInputFormat; |
| import org.apache.flink.api.common.io.FilePathFilter; |
| @@ -1589,7 +1591,6 @@ public class StreamExecutionEnvironment { |
| * the user defined type information for the stream |
| * @return the data stream constructed |
| */ |
| - @SuppressWarnings("unchecked") |
| public <OUT> DataStreamSource<OUT> addSource(SourceFunction<OUT> function, String sourceName, TypeInformation<OUT> typeInfo) { |
| |
| TypeInformation<OUT> resolvedTypeInfo = getTypeInfo(function, sourceName, SourceFunction.class, typeInfo); |
| @@ -1613,9 +1614,12 @@ public class StreamExecutionEnvironment { |
| * type of the returned stream |
| * @return the data stream constructed |
| */ |
| - @PublicEvolving |
| - public <OUT> DataStreamSource<OUT> continuousSource(Source<OUT, ?, ?> source, String sourceName) { |
| - return continuousSource(source, sourceName, null); |
| + @Experimental |
| + public <OUT> DataStreamSource<OUT> continuousSource( |
| + Source<OUT, ?, ?> source, |
| + WatermarkStrategy<OUT> timestampsAndWatermarks, |
| + String sourceName) { |
| + return continuousSource(source, timestampsAndWatermarks, sourceName, null); |
| } |
| |
| /** |
| @@ -1631,13 +1635,21 @@ public class StreamExecutionEnvironment { |
| * the user defined type information for the stream |
| * @return the data stream constructed |
| */ |
| - @PublicEvolving |
| + @Experimental |
| public <OUT> DataStreamSource<OUT> continuousSource( |
| Source<OUT, ?, ?> source, |
| + WatermarkStrategy<OUT> timestampsAndWatermarks, |
| String sourceName, |
| TypeInformation<OUT> typeInfo) { |
| - TypeInformation<OUT> resolvedTypeInfo = getTypeInfo(source, sourceName, Source.class, typeInfo); |
| - return new DataStreamSource<>(this, source, resolvedTypeInfo, sourceName); |
| + |
| + final TypeInformation<OUT> resolvedTypeInfo = getTypeInfo(source, sourceName, Source.class, typeInfo); |
| + |
| + return new DataStreamSource<>( |
| + this, |
| + checkNotNull(source, "source"), |
| + checkNotNull(timestampsAndWatermarks, "timestampsAndWatermarks"), |
| + checkNotNull(resolvedTypeInfo), |
| + checkNotNull(sourceName)); |
| } |
| |
| /** |
| |
| |
| |
| |
| @@ -19,11 +19,12 @@ package org.apache.flink.streaming.api.operators; |
| |
| import org.apache.flink.annotation.Internal; |
| import org.apache.flink.annotation.VisibleForTesting; |
| +import org.apache.flink.api.common.eventtime.WatermarkStrategy; |
| import org.apache.flink.api.common.state.ListState; |
| import org.apache.flink.api.common.state.ListStateDescriptor; |
| import org.apache.flink.api.common.typeutils.base.array.BytePrimitiveArraySerializer; |
| +import org.apache.flink.api.connector.source.ReaderOutput; |
| import org.apache.flink.api.connector.source.SourceEvent; |
| -import org.apache.flink.api.connector.source.SourceOutput; |
| import org.apache.flink.api.connector.source.SourceReader; |
| import org.apache.flink.api.connector.source.SourceReaderContext; |
| import org.apache.flink.api.connector.source.SourceSplit; |
| @@ -38,8 +39,10 @@ import org.apache.flink.runtime.source.event.ReaderRegistrationEvent; |
| import org.apache.flink.runtime.source.event.SourceEventWrapper; |
| import org.apache.flink.runtime.state.StateInitializationContext; |
| import org.apache.flink.runtime.state.StateSnapshotContext; |
| +import org.apache.flink.streaming.api.operators.source.TimestampsAndWatermarks; |
| import org.apache.flink.streaming.api.operators.util.SimpleVersionedListState; |
| import org.apache.flink.streaming.runtime.io.PushingAsyncDataInput; |
| +import org.apache.flink.streaming.runtime.tasks.ProcessingTimeService; |
| import org.apache.flink.util.CollectionUtil; |
| |
| import java.util.List; |
| @@ -81,30 +84,47 @@ public class SourceOperator<OUT, SplitT extends SourceSplit> |
| /** The event gateway through which this operator talks to its coordinator. */ |
| private final OperatorEventGateway operatorEventGateway; |
| |
| - // ---- lazily initialized fields ---- |
| + /** The factory for timestamps and watermark generators. */ |
| + private final WatermarkStrategy<OUT> watermarkStrategy; |
| + |
| + // ---- lazily initialized fields (these fields are the "hot" fields) ---- |
| |
| /** The source reader that does most of the work. */ |
| private SourceReader<OUT, SplitT> sourceReader; |
| |
| + private ReaderOutput<OUT> currentMainOutput; |
| + |
| + private DataOutput<OUT> lastInvokedOutput; |
| + |
| /** The state that holds the currently assigned splits. */ |
| private ListState<SplitT> readerState; |
| |
| + /** The event time and watermarking logic. Ideally this would be eagerly passed into this operator, |
| + * but we currently need to instantiate this lazily, because the metric groups exist only later. */ |
| + private TimestampsAndWatermarks<OUT> eventTimeLogic; |
| + |
| public SourceOperator( |
| Function<SourceReaderContext, SourceReader<OUT, SplitT>> readerFactory, |
| OperatorEventGateway operatorEventGateway, |
| - SimpleVersionedSerializer<SplitT> splitSerializer) { |
| + SimpleVersionedSerializer<SplitT> splitSerializer, |
| + WatermarkStrategy<OUT> watermarkStrategy, |
| + ProcessingTimeService timeService) { |
| |
| this.readerFactory = checkNotNull(readerFactory); |
| this.operatorEventGateway = checkNotNull(operatorEventGateway); |
| this.splitSerializer = checkNotNull(splitSerializer); |
| + this.watermarkStrategy = checkNotNull(watermarkStrategy); |
| + this.processingTimeService = timeService; |
| } |
| |
| @Override |
| public void open() throws Exception { |
| + final MetricGroup metricGroup = getMetricGroup(); |
| + |
| final SourceReaderContext context = new SourceReaderContext() { |
| @Override |
| public MetricGroup metricGroup() { |
| - return getRuntimeContext().getMetricGroup(); |
| + return metricGroup; |
| } |
| |
| @Override |
| @@ -113,6 +133,15 @@ public class SourceOperator<OUT, SplitT extends SourceSplit> |
| } |
| }; |
| |
| + // in the future when we support both batch and streaming modes for the source operator, |
| + // and when this one is migrated to the "eager initialization" operator (StreamOperatorV2), |
| + // then we should evaluate this during operator construction. |
| + eventTimeLogic = TimestampsAndWatermarks.createStreamingEventTimeLogic( |
| + watermarkStrategy, |
| + metricGroup, |
| + getProcessingTimeService(), |
| + getExecutionConfig().getAutoWatermarkInterval()); |
| + |
| sourceReader = readerFactory.apply(context); |
| |
| // restore the state if necessary. |
| @@ -125,12 +154,31 @@ public class SourceOperator<OUT, SplitT extends SourceSplit> |
| sourceReader.start(); |
| // Register the reader to the coordinator. |
| registerReader(); |
| + |
| + eventTimeLogic.startPeriodicWatermarkEmits(); |
| + } |
| + |
| + @Override |
| + public void close() throws Exception { |
| + eventTimeLogic.stopPeriodicWatermarkEmits(); |
| + super.close(); |
| } |
| |
| @Override |
| - @SuppressWarnings("unchecked") |
| public InputStatus emitNext(DataOutput<OUT> output) throws Exception { |
| - return sourceReader.pollNext((SourceOutput<OUT>) output); |
| + // guarding an assumptions we currently make due to the fact that certain classes |
| + // assume a constant output |
| + assert lastInvokedOutput == output || lastInvokedOutput == null; |
| + |
| + // short circuit the common case (every invocation except the first) |
| + if (currentMainOutput != null) { |
| + return sourceReader.pollNext(currentMainOutput); |
| + } |
| + |
| + // this creates a batch or streaming output based on the runtime mode |
| + currentMainOutput = eventTimeLogic.createMainOutput(output); |
| + lastInvokedOutput = output; |
| + return sourceReader.pollNext(currentMainOutput); |
| } |
| |
| @Override |
| |
| |
| |
| |
| @@ -18,6 +18,7 @@ |
| |
| package org.apache.flink.streaming.api.operators; |
| |
| +import org.apache.flink.api.common.eventtime.WatermarkStrategy; |
| import org.apache.flink.api.connector.source.Source; |
| import org.apache.flink.api.connector.source.SourceReader; |
| import org.apache.flink.api.connector.source.SourceReaderContext; |
| @@ -27,29 +28,40 @@ import org.apache.flink.runtime.jobgraph.OperatorID; |
| import org.apache.flink.runtime.operators.coordination.OperatorCoordinator; |
| import org.apache.flink.runtime.operators.coordination.OperatorEventGateway; |
| import org.apache.flink.runtime.source.coordinator.SourceCoordinatorProvider; |
| +import org.apache.flink.streaming.runtime.tasks.ProcessingTimeService; |
| +import org.apache.flink.streaming.runtime.tasks.ProcessingTimeServiceAware; |
| |
| import java.util.function.Function; |
| |
| +import static org.apache.flink.util.Preconditions.checkNotNull; |
| + |
| /** |
| * The Factory class for {@link SourceOperator}. |
| */ |
| public class SourceOperatorFactory<OUT> extends AbstractStreamOperatorFactory<OUT> |
| - implements CoordinatedOperatorFactory<OUT> { |
| + implements CoordinatedOperatorFactory<OUT>, ProcessingTimeServiceAware { |
| |
| private static final long serialVersionUID = 1L; |
| |
| /** The {@link Source} to create the {@link SourceOperator}. */ |
| private final Source<OUT, ?, ?> source; |
| |
| + /** The event time setup (timestamp assigners, watermark generators, etc.). */ |
| + private final WatermarkStrategy<OUT> watermarkStrategy; |
| + |
| /** The number of worker thread for the source coordinator. */ |
| private final int numCoordinatorWorkerThread; |
| |
| - public SourceOperatorFactory(Source<OUT, ?, ?> source) { |
| - this(source, 1); |
| + public SourceOperatorFactory(Source<OUT, ?, ?> source, WatermarkStrategy<OUT> watermarkStrategy) { |
| + this(source, watermarkStrategy, 1); |
| } |
| |
| - public SourceOperatorFactory(Source<OUT, ?, ?> source, int numCoordinatorWorkerThread) { |
| - this.source = source; |
| + public SourceOperatorFactory( |
| + Source<OUT, ?, ?> source, |
| + WatermarkStrategy<OUT> watermarkStrategy, |
| + int numCoordinatorWorkerThread) { |
| + this.source = checkNotNull(source); |
| + this.watermarkStrategy = checkNotNull(watermarkStrategy); |
| this.numCoordinatorWorkerThread = numCoordinatorWorkerThread; |
| } |
| |
| @@ -61,7 +73,9 @@ public class SourceOperatorFactory<OUT> extends AbstractStreamOperatorFactory<OU |
| final SourceOperator<OUT, ?> sourceOperator = instantiateSourceOperator( |
| source::createReader, |
| gateway, |
| - source.getSplitSerializer()); |
| + source.getSplitSerializer(), |
| + watermarkStrategy, |
| + parameters.getProcessingTimeService()); |
| |
| sourceOperator.setup(parameters.getContainingTask(), parameters.getStreamConfig(), parameters.getOutput()); |
| parameters.getOperatorEventDispatcher().registerEventHandler(operatorId, sourceOperator); |
| @@ -99,7 +113,9 @@ public class SourceOperatorFactory<OUT> extends AbstractStreamOperatorFactory<OU |
| private static <T, SplitT extends SourceSplit> SourceOperator<T, SplitT> instantiateSourceOperator( |
| Function<SourceReaderContext, SourceReader<T, ?>> readerFactory, |
| OperatorEventGateway eventGateway, |
| - SimpleVersionedSerializer<?> splitSerializer) { |
| + SimpleVersionedSerializer<?> splitSerializer, |
| + WatermarkStrategy<T> watermarkStrategy, |
| + ProcessingTimeService timeService) { |
| |
| // jumping through generics hoops: cast the generics away to then cast them back more strictly typed |
| final Function<SourceReaderContext, SourceReader<T, SplitT>> typedReaderFactory = |
| @@ -110,6 +126,8 @@ public class SourceOperatorFactory<OUT> extends AbstractStreamOperatorFactory<OU |
| return new SourceOperator<>( |
| typedReaderFactory, |
| eventGateway, |
| - typedSplitSerializer); |
| + typedSplitSerializer, |
| + watermarkStrategy, |
| + timeService); |
| } |
| } |
| |
| |
| |
| |
| @@ -26,6 +26,7 @@ import org.apache.flink.streaming.runtime.tasks.ProcessingTimeServiceAware; |
| import org.apache.flink.streaming.runtime.tasks.StreamTask; |
| |
| import java.util.Optional; |
| +import java.util.function.Supplier; |
| |
| /** |
| * A utility to instantiate new operators with a given factory. |
| @@ -51,13 +52,18 @@ public class StreamOperatorFactoryUtil { |
| MailboxExecutor mailboxExecutor = containingTask.getMailboxExecutorFactory().createExecutor(configuration.getChainIndex()); |
| |
| if (operatorFactory instanceof YieldingOperatorFactory) { |
| - ((YieldingOperatorFactory) operatorFactory).setMailboxExecutor(mailboxExecutor); |
| + ((YieldingOperatorFactory<?>) operatorFactory).setMailboxExecutor(mailboxExecutor); |
| } |
| |
| - ProcessingTimeService processingTimeService = null; |
| + final Supplier<ProcessingTimeService> processingTimeServiceFactory = |
| + () -> containingTask.getProcessingTimeServiceFactory().createProcessingTimeService(mailboxExecutor); |
| + |
| + final ProcessingTimeService processingTimeService; |
| if (operatorFactory instanceof ProcessingTimeServiceAware) { |
| - processingTimeService = containingTask.getProcessingTimeServiceFactory().createProcessingTimeService(mailboxExecutor); |
| + processingTimeService = processingTimeServiceFactory.get(); |
| ((ProcessingTimeServiceAware) operatorFactory).setProcessingTimeService(processingTimeService); |
| + } else { |
| + processingTimeService = null; |
| } |
| |
| // TODO: what to do with ProcessingTimeServiceAware? |
| @@ -66,7 +72,7 @@ public class StreamOperatorFactoryUtil { |
| containingTask, |
| configuration, |
| output, |
| - processingTimeService, |
| + processingTimeService != null ? () -> processingTimeService : processingTimeServiceFactory, |
| operatorEventDispatcher)); |
| return new Tuple2<>(op, Optional.ofNullable(processingTimeService)); |
| } |
| |
| |
| |
| |
| @@ -25,6 +25,10 @@ import org.apache.flink.streaming.runtime.streamrecord.StreamRecord; |
| import org.apache.flink.streaming.runtime.tasks.ProcessingTimeService; |
| import org.apache.flink.streaming.runtime.tasks.StreamTask; |
| |
| +import javax.annotation.Nullable; |
| + |
| +import java.util.function.Supplier; |
| + |
| /** |
| * Helper class to construct {@link AbstractStreamOperatorV2}. Wraps couple of internal parameters |
| * to simplify for users construction of classes extending {@link AbstractStreamOperatorV2} and to |
| @@ -37,19 +41,23 @@ public class StreamOperatorParameters<OUT> { |
| private final StreamTask<?, ?> containingTask; |
| private final StreamConfig config; |
| private final Output<StreamRecord<OUT>> output; |
| - private final ProcessingTimeService processingTimeService; |
| + private final Supplier<ProcessingTimeService> processingTimeServiceFactory; |
| private final OperatorEventDispatcher operatorEventDispatcher; |
| |
| + /** The ProcessingTimeService, lazily created, but cached so that we don't create more than one. */ |
| + @Nullable |
| + private ProcessingTimeService processingTimeService; |
| + |
| public StreamOperatorParameters( |
| StreamTask<?, ?> containingTask, |
| StreamConfig config, |
| Output<StreamRecord<OUT>> output, |
| - ProcessingTimeService processingTimeService, |
| + Supplier<ProcessingTimeService> processingTimeServiceFactory, |
| OperatorEventDispatcher operatorEventDispatcher) { |
| this.containingTask = containingTask; |
| this.config = config; |
| this.output = output; |
| - this.processingTimeService = processingTimeService; |
| + this.processingTimeServiceFactory = processingTimeServiceFactory; |
| this.operatorEventDispatcher = operatorEventDispatcher; |
| } |
| |
| @@ -66,6 +74,9 @@ public class StreamOperatorParameters<OUT> { |
| } |
| |
| public ProcessingTimeService getProcessingTimeService() { |
| + if (processingTimeService == null) { |
| + processingTimeService = processingTimeServiceFactory.get(); |
| + } |
| return processingTimeService; |
| } |
| |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,126 @@ |
| +/* |
| + * 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.flink.streaming.api.operators.source; |
| + |
| +import org.apache.flink.annotation.Internal; |
| +import org.apache.flink.api.common.eventtime.TimestampAssigner; |
| +import org.apache.flink.api.common.eventtime.Watermark; |
| +import org.apache.flink.api.connector.source.ReaderOutput; |
| +import org.apache.flink.api.connector.source.SourceOutput; |
| +import org.apache.flink.streaming.runtime.io.PushingAsyncDataInput; |
| +import org.apache.flink.streaming.runtime.streamrecord.StreamRecord; |
| +import org.apache.flink.streaming.runtime.tasks.ExceptionInChainedOperatorException; |
| + |
| +import static org.apache.flink.util.Preconditions.checkNotNull; |
| + |
| +/** |
| + * An implementation of {@link TimestampsAndWatermarks} to be used during batch execution of a |
| + * program. Batch execution has no watermarks, so all watermark related operations in this |
| + * implementation are no-ops. |
| + * |
| + * @param <T> The type of the emitted records. |
| + */ |
| +@Internal |
| +public class BatchTimestampsAndWatermarks<T> implements TimestampsAndWatermarks<T> { |
| + |
| + private final TimestampAssigner<T> timestamps; |
| + |
| + /** |
| + * Creates a new BatchTimestampsAndWatermarks with the given TimestampAssigner. |
| + */ |
| + public BatchTimestampsAndWatermarks(TimestampAssigner<T> timestamps) { |
| + this.timestamps = checkNotNull(timestamps); |
| + } |
| + |
| + @Override |
| + public ReaderOutput<T> createMainOutput(PushingAsyncDataInput.DataOutput<T> output) { |
| + checkNotNull(output); |
| + return new TimestampsOnlyOutput<>(output, timestamps); |
| + } |
| + |
| + @Override |
| + public void startPeriodicWatermarkEmits() { |
| + // no periodic watermarks in batch processing |
| + } |
| + |
| + @Override |
| + public void stopPeriodicWatermarkEmits() { |
| + // no periodic watermarks in batch processing |
| + } |
| + |
| + // ------------------------------------------------------------------------ |
| + |
| + /** |
| + * A simple implementation of {@link SourceOutput} and {@link ReaderOutput} that extracts |
| + * timestamps but has no watermarking logic. Because only watermarking logic has state per |
| + * Source Split, the same instance gets shared across all Source Splits. |
| + * |
| + * @param <T> The type of the emitted records. |
| + */ |
| + private static final class TimestampsOnlyOutput<T> implements ReaderOutput<T> { |
| + |
| + private final PushingAsyncDataInput.DataOutput<T> output; |
| + private final TimestampAssigner<T> timestampAssigner; |
| + |
| + private TimestampsOnlyOutput( |
| + PushingAsyncDataInput.DataOutput<T> output, |
| + TimestampAssigner<T> timestampAssigner) { |
| + |
| + this.output = output; |
| + this.timestampAssigner = timestampAssigner; |
| + } |
| + |
| + @Override |
| + public void collect(T record) { |
| + collect(record, TimestampAssigner.NO_TIMESTAMP); |
| + } |
| + |
| + @Override |
| + public void collect(T record, long timestamp) { |
| + try { |
| + output.emitRecord(new StreamRecord<>(record, timestampAssigner.extractTimestamp(record, timestamp))); |
| + } catch (ExceptionInChainedOperatorException e) { |
| + throw e; |
| + } catch (Exception e) { |
| + throw new ExceptionInChainedOperatorException(e); |
| + } |
| + } |
| + |
| + @Override |
| + public void emitWatermark(Watermark watermark) { |
| + // do nothing, this does not forward any watermarks manually emitted by the source directly |
| + } |
| + |
| + @Override |
| + public void markIdle() { |
| + // do nothing, because without watermarks there is no idleness |
| + } |
| + |
| + @Override |
| + public SourceOutput<T> createOutputForSplit(String splitId) { |
| + // we don't need per-partition instances, because we do not generate watermarks |
| + return this; |
| + } |
| + |
| + @Override |
| + public void releaseOutputForSplit(String splitId) { |
| + // nothing to release, because we do not create per-partition instances |
| + } |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,179 @@ |
| +/* |
| + * 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.flink.streaming.api.operators.source; |
| + |
| +import org.apache.flink.annotation.Internal; |
| +import org.apache.flink.api.common.eventtime.TimestampAssigner; |
| +import org.apache.flink.api.common.eventtime.Watermark; |
| +import org.apache.flink.api.common.eventtime.WatermarkGenerator; |
| +import org.apache.flink.api.common.eventtime.WatermarkOutput; |
| +import org.apache.flink.api.connector.source.SourceOutput; |
| +import org.apache.flink.streaming.runtime.io.PushingAsyncDataInput; |
| +import org.apache.flink.streaming.runtime.streamrecord.StreamRecord; |
| +import org.apache.flink.streaming.runtime.tasks.ExceptionInChainedOperatorException; |
| + |
| +import static org.apache.flink.util.Preconditions.checkNotNull; |
| + |
| +/** |
| + * Implementation of the SourceOutput. The records emitted to this output are pushed into a given |
| + * {@link PushingAsyncDataInput.DataOutput}. The watermarks are pushed into the same output, or |
| + * into a separate {@link WatermarkOutput}, if one is provided. |
| + * |
| + * <h2>Periodic Watermarks</h2> |
| + * |
| + * <p>This output does not implement automatic periodic watermark emission. The |
| + * method {@link SourceOutputWithWatermarks#emitPeriodicWatermark()} needs to be called periodically. |
| + * |
| + * <h2>Note on Performance Considerations</h2> |
| + * |
| + * <p>The methods {@link SourceOutput#collect(Object)} and {@link SourceOutput#collect(Object, long)} |
| + * are highly performance-critical (part of the hot loop). To make the code as JIT friendly as possible, |
| + * we want to have only a single implementation of these two methods, across all classes. |
| + * That way, the JIT compiler can de-virtualize (and inline) them better. |
| + * |
| + * <p>Currently, we have one implementation of these methods in the batch case (see class |
| + * {@link BatchTimestampsAndWatermarks}) and one for the streaming case (this class). When the JVM |
| + * is dedicated to a single job (or type of job) only one of these classes will be loaded. In mixed |
| + * job setups, we still have a bimorphic method (rather than a poly/-/mega-morphic method). |
| + * |
| + * @param <T> The type of emitted records. |
| + */ |
| +@Internal |
| +public class SourceOutputWithWatermarks<T> implements SourceOutput<T> { |
| + |
| + private final PushingAsyncDataInput.DataOutput<T> recordsOutput; |
| + |
| + private final TimestampAssigner<T> timestampAssigner; |
| + |
| + private final WatermarkGenerator<T> watermarkGenerator; |
| + |
| + private final WatermarkOutput onEventWatermarkOutput; |
| + |
| + private final WatermarkOutput periodicWatermarkOutput; |
| + |
| + /** |
| + * Creates a new SourceOutputWithWatermarks that emits records to the given DataOutput |
| + * and watermarks to the (possibly different) WatermarkOutput. |
| + */ |
| + protected SourceOutputWithWatermarks( |
| + PushingAsyncDataInput.DataOutput<T> recordsOutput, |
| + WatermarkOutput onEventWatermarkOutput, |
| + WatermarkOutput periodicWatermarkOutput, |
| + TimestampAssigner<T> timestampAssigner, |
| + WatermarkGenerator<T> watermarkGenerator) { |
| + |
| + this.recordsOutput = checkNotNull(recordsOutput); |
| + this.onEventWatermarkOutput = checkNotNull(onEventWatermarkOutput); |
| + this.periodicWatermarkOutput = checkNotNull(periodicWatermarkOutput); |
| + this.timestampAssigner = checkNotNull(timestampAssigner); |
| + this.watermarkGenerator = checkNotNull(watermarkGenerator); |
| + } |
| + |
| + // ------------------------------------------------------------------------ |
| + // SourceOutput Methods |
| + // |
| + // Note that the two methods below are final, as a partial enforcement |
| + // of the performance design goal mentioned in the class-level comment. |
| + // ------------------------------------------------------------------------ |
| + |
| + @Override |
| + public final void collect(T record) { |
| + collect(record, TimestampAssigner.NO_TIMESTAMP); |
| + } |
| + |
| + @Override |
| + public final void collect(T record, long timestamp) { |
| + try { |
| + final long assignedTimestamp = timestampAssigner.extractTimestamp(record, timestamp); |
| + |
| + // IMPORTANT: The event must be emitted before the watermark generator is called. |
| + recordsOutput.emitRecord(new StreamRecord<>(record, assignedTimestamp)); |
| + watermarkGenerator.onEvent(record, assignedTimestamp, onEventWatermarkOutput); |
| + } catch (ExceptionInChainedOperatorException e) { |
| + throw e; |
| + } catch (Exception e) { |
| + throw new ExceptionInChainedOperatorException(e); |
| + } |
| + } |
| + |
| + // ------------------------------------------------------------------------ |
| + // WatermarkOutput Methods |
| + // |
| + // These two methods are final as well, to enforce the contract that the |
| + // watermarks from emitWatermark(Watermark) go to the same output as the |
| + // watermarks from the watermarkGenerator.onEvent(...) calls in the collect(...) |
| + // methods. |
| + // ------------------------------------------------------------------------ |
| + |
| + @Override |
| + public final void emitWatermark(Watermark watermark) { |
| + onEventWatermarkOutput.emitWatermark(watermark); |
| + } |
| + |
| + @Override |
| + public final void markIdle() { |
| + onEventWatermarkOutput.markIdle(); |
| + } |
| + |
| + public final void emitPeriodicWatermark() { |
| + watermarkGenerator.onPeriodicEmit(periodicWatermarkOutput); |
| + } |
| + |
| + // ------------------------------------------------------------------------ |
| + // Factories |
| + // ------------------------------------------------------------------------ |
| + |
| + /** |
| + * Creates a new SourceOutputWithWatermarks that emits records to the given DataOutput |
| + * and watermarks to the (possibly different) WatermarkOutput. |
| + */ |
| + public static <E> SourceOutputWithWatermarks<E> createWithSameOutputs( |
| + PushingAsyncDataInput.DataOutput<E> recordsAndWatermarksOutput, |
| + TimestampAssigner<E> timestampAssigner, |
| + WatermarkGenerator<E> watermarkGenerator) { |
| + |
| + final WatermarkOutput watermarkOutput = new WatermarkToDataOutput(recordsAndWatermarksOutput); |
| + |
| + return new SourceOutputWithWatermarks<>( |
| + recordsAndWatermarksOutput, |
| + watermarkOutput, |
| + watermarkOutput, |
| + timestampAssigner, |
| + watermarkGenerator); |
| + } |
| + |
| + /** |
| + * Creates a new SourceOutputWithWatermarks that emits records to the given DataOutput |
| + * and watermarks to the different WatermarkOutputs. |
| + */ |
| + public static <E> SourceOutputWithWatermarks<E> createWithSeparateOutputs( |
| + PushingAsyncDataInput.DataOutput<E> recordsOutput, |
| + WatermarkOutput onEventWatermarkOutput, |
| + WatermarkOutput periodicWatermarkOutput, |
| + TimestampAssigner<E> timestampAssigner, |
| + WatermarkGenerator<E> watermarkGenerator) { |
| + |
| + return new SourceOutputWithWatermarks<>( |
| + recordsOutput, |
| + onEventWatermarkOutput, |
| + periodicWatermarkOutput, |
| + timestampAssigner, |
| + watermarkGenerator); |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,247 @@ |
| +/* |
| + * 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.flink.streaming.api.operators.source; |
| + |
| +import org.apache.flink.annotation.Internal; |
| +import org.apache.flink.api.common.eventtime.TimestampAssigner; |
| +import org.apache.flink.api.common.eventtime.WatermarkGenerator; |
| +import org.apache.flink.api.common.eventtime.WatermarkGeneratorSupplier; |
| +import org.apache.flink.api.common.eventtime.WatermarkOutput; |
| +import org.apache.flink.api.common.eventtime.WatermarkOutputMultiplexer; |
| +import org.apache.flink.api.connector.source.ReaderOutput; |
| +import org.apache.flink.api.connector.source.SourceOutput; |
| +import org.apache.flink.streaming.runtime.io.PushingAsyncDataInput; |
| +import org.apache.flink.streaming.runtime.tasks.ProcessingTimeService; |
| + |
| +import javax.annotation.Nullable; |
| + |
| +import java.time.Duration; |
| +import java.util.LinkedHashMap; |
| +import java.util.Map; |
| +import java.util.concurrent.ScheduledFuture; |
| + |
| +import static org.apache.flink.util.Preconditions.checkState; |
| + |
| +/** |
| + * An implementation of timestamp extraction and watermark generation logic for streaming sources. |
| + * |
| + * @param <T> The type of the emitted records. |
| + */ |
| +@Internal |
| +public class StreamingTimestampsAndWatermarks<T> implements TimestampsAndWatermarks<T> { |
| + |
| + private final TimestampAssigner<T> timestampAssigner; |
| + |
| + private final WatermarkGeneratorSupplier<T> watermarksFactory; |
| + |
| + private final WatermarkGeneratorSupplier.Context watermarksContext; |
| + |
| + private final ProcessingTimeService timeService; |
| + |
| + private final long periodicWatermarkInterval; |
| + |
| + @Nullable |
| + private SplitLocalOutputs<T> currentPerSplitOutputs; |
| + |
| + @Nullable |
| + private StreamingReaderOutput<T> currentMainOutput; |
| + |
| + @Nullable |
| + private ScheduledFuture<?> periodicEmitHandle; |
| + |
| + public StreamingTimestampsAndWatermarks( |
| + TimestampAssigner<T> timestampAssigner, |
| + WatermarkGeneratorSupplier<T> watermarksFactory, |
| + WatermarkGeneratorSupplier.Context watermarksContext, |
| + ProcessingTimeService timeService, |
| + Duration periodicWatermarkInterval) { |
| + |
| + this.timestampAssigner = timestampAssigner; |
| + this.watermarksFactory = watermarksFactory; |
| + this.watermarksContext = watermarksContext; |
| + this.timeService = timeService; |
| + |
| + long periodicWatermarkIntervalMillis; |
| + try { |
| + periodicWatermarkIntervalMillis = periodicWatermarkInterval.toMillis(); |
| + } catch (ArithmeticException ignored) { |
| + // long integer overflow |
| + periodicWatermarkIntervalMillis = Long.MAX_VALUE; |
| + } |
| + this.periodicWatermarkInterval = periodicWatermarkIntervalMillis; |
| + } |
| + |
| + // ------------------------------------------------------------------------ |
| + |
| + @Override |
| + public ReaderOutput<T> createMainOutput(PushingAsyncDataInput.DataOutput<T> output) { |
| + // At the moment, we assume only one output is ever created! |
| + // This assumption is strict, currently, because many of the classes in this implementation do not |
| + // support re-assigning the underlying output |
| + checkState(currentMainOutput == null && currentPerSplitOutputs == null, "already created a main output"); |
| + |
| + final WatermarkOutput watermarkOutput = new WatermarkToDataOutput(output); |
| + final WatermarkGenerator<T> watermarkGenerator = watermarksFactory.createWatermarkGenerator(watermarksContext); |
| + |
| + currentPerSplitOutputs = new SplitLocalOutputs<>( |
| + output, |
| + watermarkOutput, |
| + timestampAssigner, |
| + watermarksFactory, |
| + watermarksContext); |
| + |
| + currentMainOutput = new StreamingReaderOutput<>( |
| + output, |
| + watermarkOutput, |
| + timestampAssigner, |
| + watermarkGenerator, |
| + currentPerSplitOutputs); |
| + |
| + return currentMainOutput; |
| + } |
| + |
| + @Override |
| + public void startPeriodicWatermarkEmits() { |
| + checkState(periodicEmitHandle == null, "periodic emitter already started"); |
| + |
| + if (periodicWatermarkInterval == 0) { |
| + // a value of zero means not activated |
| + return; |
| + } |
| + |
| + periodicEmitHandle = timeService.scheduleWithFixedDelay( |
| + this::triggerPeriodicEmit, |
| + periodicWatermarkInterval, |
| + periodicWatermarkInterval); |
| + } |
| + |
| + @Override |
| + public void stopPeriodicWatermarkEmits() { |
| + if (periodicEmitHandle != null) { |
| + periodicEmitHandle.cancel(false); |
| + periodicEmitHandle = null; |
| + } |
| + } |
| + |
| + void triggerPeriodicEmit(@SuppressWarnings("unused") long wallClockTimestamp) { |
| + if (currentPerSplitOutputs != null) { |
| + currentPerSplitOutputs.emitPeriodicWatermark(); |
| + } |
| + if (currentMainOutput != null) { |
| + currentMainOutput.emitPeriodicWatermark(); |
| + } |
| + } |
| + |
| + // ------------------------------------------------------------------------ |
| + |
| + private static final class StreamingReaderOutput<T> extends SourceOutputWithWatermarks<T> implements ReaderOutput<T> { |
| + |
| + private final SplitLocalOutputs<T> splitLocalOutputs; |
| + |
| + StreamingReaderOutput( |
| + PushingAsyncDataInput.DataOutput<T> output, |
| + WatermarkOutput watermarkOutput, |
| + TimestampAssigner<T> timestampAssigner, |
| + WatermarkGenerator<T> watermarkGenerator, |
| + SplitLocalOutputs<T> splitLocalOutputs) { |
| + |
| + super(output, watermarkOutput, watermarkOutput, timestampAssigner, watermarkGenerator); |
| + this.splitLocalOutputs = splitLocalOutputs; |
| + } |
| + |
| + @Override |
| + public SourceOutput<T> createOutputForSplit(String splitId) { |
| + return splitLocalOutputs.createOutputForSplit(splitId); |
| + } |
| + |
| + @Override |
| + public void releaseOutputForSplit(String splitId) { |
| + splitLocalOutputs.releaseOutputForSplit(splitId); |
| + } |
| + } |
| + |
| + // ------------------------------------------------------------------------ |
| + |
| + /** |
| + * A holder and factory for split-local {@link SourceOutput}s. The split-local outputs maintain |
| + * local watermark generators with their own state, to facilitate per-split watermarking logic. |
| + * |
| + * @param <T> The type of the emitted records. |
| + */ |
| + private static final class SplitLocalOutputs<T> { |
| + |
| + private final WatermarkOutputMultiplexer watermarkMultiplexer; |
| + private final Map<String, SourceOutputWithWatermarks<T>> localOutputs; |
| + private final PushingAsyncDataInput.DataOutput<T> recordOutput; |
| + private final TimestampAssigner<T> timestampAssigner; |
| + private final WatermarkGeneratorSupplier<T> watermarksFactory; |
| + private final WatermarkGeneratorSupplier.Context watermarkContext; |
| + |
| + private SplitLocalOutputs( |
| + PushingAsyncDataInput.DataOutput<T> recordOutput, |
| + WatermarkOutput watermarkOutput, |
| + TimestampAssigner<T> timestampAssigner, |
| + WatermarkGeneratorSupplier<T> watermarksFactory, |
| + WatermarkGeneratorSupplier.Context watermarkContext) { |
| + |
| + this.recordOutput = recordOutput; |
| + this.timestampAssigner = timestampAssigner; |
| + this.watermarksFactory = watermarksFactory; |
| + this.watermarkContext = watermarkContext; |
| + |
| + this.watermarkMultiplexer = new WatermarkOutputMultiplexer(watermarkOutput); |
| + this.localOutputs = new LinkedHashMap<>(); // we use a LinkedHashMap because it iterates faster |
| + } |
| + |
| + SourceOutput<T> createOutputForSplit(String splitId) { |
| + final SourceOutputWithWatermarks<T> previous = localOutputs.get(splitId); |
| + if (previous != null) { |
| + return previous; |
| + } |
| + |
| + watermarkMultiplexer.registerNewOutput(splitId); |
| + final WatermarkOutput onEventOutput = watermarkMultiplexer.getImmediateOutput(splitId); |
| + final WatermarkOutput periodicOutput = watermarkMultiplexer.getDeferredOutput(splitId); |
| + |
| + final WatermarkGenerator<T> watermarks = watermarksFactory.createWatermarkGenerator(watermarkContext); |
| + |
| + final SourceOutputWithWatermarks<T> localOutput = SourceOutputWithWatermarks.createWithSeparateOutputs( |
| + recordOutput, onEventOutput, periodicOutput, timestampAssigner, watermarks); |
| + |
| + localOutputs.put(splitId, localOutput); |
| + return localOutput; |
| + } |
| + |
| + void releaseOutputForSplit(String splitId) { |
| + localOutputs.remove(splitId); |
| + watermarkMultiplexer.unregisterOutput(splitId); |
| + } |
| + |
| + void emitPeriodicWatermark() { |
| + // The call in the loop only records the next watermark candidate for each local output. |
| + // The call to 'watermarkMultiplexer.onPeriodicEmit()' actually merges the watermarks. |
| + // That way, we save inefficient repeated merging of (partially outdated) watermarks before |
| + // all local generators have emitted their candidates. |
| + for (SourceOutputWithWatermarks<?> output : localOutputs.values()) { |
| + output.emitPeriodicWatermark(); |
| + } |
| + watermarkMultiplexer.onPeriodicEmit(); |
| + } |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,92 @@ |
| +/* |
| + * 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.flink.streaming.api.operators.source; |
| + |
| +import org.apache.flink.annotation.Internal; |
| +import org.apache.flink.api.common.eventtime.TimestampAssigner; |
| +import org.apache.flink.api.common.eventtime.WatermarkOutput; |
| +import org.apache.flink.api.common.eventtime.WatermarkStrategy; |
| +import org.apache.flink.api.connector.source.ReaderOutput; |
| +import org.apache.flink.metrics.MetricGroup; |
| +import org.apache.flink.streaming.runtime.io.PushingAsyncDataInput; |
| +import org.apache.flink.streaming.runtime.tasks.ProcessingTimeService; |
| + |
| +import java.time.Duration; |
| + |
| +/** |
| + * Basic interface for the timestamp extraction and watermark generation logic for the |
| + * {@link org.apache.flink.api.connector.source.SourceReader}. |
| + * |
| + * <p>Implementations of this class may or may not actually perform certain tasks, like watermark |
| + * generation. For example, the batch-oriented implementation typically skips all watermark generation |
| + * logic. |
| + * |
| + * @param <T> The type of the emitted records. |
| + */ |
| +@Internal |
| +public interface TimestampsAndWatermarks<T> { |
| + |
| + /** |
| + * Creates the ReaderOutput for the source reader, than internally runs the timestamp extraction and |
| + * watermark generation. |
| + */ |
| + ReaderOutput<T> createMainOutput(PushingAsyncDataInput.DataOutput<T> output); |
| + |
| + /** |
| + * Starts emitting periodic watermarks, if this implementation produces watermarks, and if |
| + * periodic watermarks are configured. |
| + * |
| + * <p>Periodic watermarks are produced by periodically calling the |
| + * {@link org.apache.flink.api.common.eventtime.WatermarkGenerator#onPeriodicEmit(WatermarkOutput)} method |
| + * of the underlying Watermark Generators. |
| + */ |
| + void startPeriodicWatermarkEmits(); |
| + |
| + /** |
| + * Stops emitting periodic watermarks. |
| + */ |
| + void stopPeriodicWatermarkEmits(); |
| + |
| + // ------------------------------------------------------------------------ |
| + // factories |
| + // ------------------------------------------------------------------------ |
| + |
| + static <E> TimestampsAndWatermarks<E> createStreamingEventTimeLogic( |
| + WatermarkStrategy<E> watermarkStrategy, |
| + MetricGroup metrics, |
| + ProcessingTimeService timeService, |
| + long periodicWatermarkIntervalMillis) { |
| + |
| + final TimestampsAndWatermarksContext context = new TimestampsAndWatermarksContext(metrics); |
| + final TimestampAssigner<E> timestampAssigner = watermarkStrategy.createTimestampAssigner(context); |
| + |
| + return new StreamingTimestampsAndWatermarks<>( |
| + timestampAssigner, watermarkStrategy, context, timeService, Duration.ofMillis(periodicWatermarkIntervalMillis)); |
| + } |
| + |
| + static <E> TimestampsAndWatermarks<E> createBatchEventTimeLogic( |
| + WatermarkStrategy<E> watermarkStrategy, |
| + MetricGroup metrics) { |
| + |
| + final TimestampsAndWatermarksContext context = new TimestampsAndWatermarksContext(metrics); |
| + final TimestampAssigner<E> timestampAssigner = watermarkStrategy.createTimestampAssigner(context); |
| + |
| + return new BatchTimestampsAndWatermarks<>(timestampAssigner); |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,46 @@ |
| +/* |
| + * 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.flink.streaming.api.operators.source; |
| + |
| +import org.apache.flink.annotation.Internal; |
| +import org.apache.flink.api.common.eventtime.TimestampAssignerSupplier; |
| +import org.apache.flink.api.common.eventtime.WatermarkGeneratorSupplier; |
| +import org.apache.flink.metrics.MetricGroup; |
| + |
| +import static org.apache.flink.util.Preconditions.checkNotNull; |
| + |
| +/** |
| + * A simple implementation of a context that is both {@link TimestampAssignerSupplier.Context} |
| + * and {@link WatermarkGeneratorSupplier.Context}. |
| + */ |
| +@Internal |
| +public final class TimestampsAndWatermarksContext |
| + implements TimestampAssignerSupplier.Context, WatermarkGeneratorSupplier.Context { |
| + |
| + private final MetricGroup metricGroup; |
| + |
| + public TimestampsAndWatermarksContext(MetricGroup metricGroup) { |
| + this.metricGroup = checkNotNull(metricGroup); |
| + } |
| + |
| + @Override |
| + public MetricGroup getMetricGroup() { |
| + return metricGroup; |
| + } |
| +} |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,86 @@ |
| +/* |
| + * 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.flink.streaming.api.operators.source; |
| + |
| +import org.apache.flink.annotation.Internal; |
| +import org.apache.flink.api.common.eventtime.Watermark; |
| +import org.apache.flink.api.common.eventtime.WatermarkOutput; |
| +import org.apache.flink.streaming.runtime.io.PushingAsyncDataInput; |
| +import org.apache.flink.streaming.runtime.streamstatus.StreamStatus; |
| +import org.apache.flink.streaming.runtime.tasks.ExceptionInChainedOperatorException; |
| + |
| +import static org.apache.flink.util.Preconditions.checkNotNull; |
| + |
| +/** |
| + * An adapter that exposes a {@link WatermarkOutput} based on a {@link PushingAsyncDataInput.DataOutput}. |
| + */ |
| +@Internal |
| +public final class WatermarkToDataOutput implements WatermarkOutput { |
| + |
| + private final PushingAsyncDataInput.DataOutput<?> output; |
| + private long maxWatermarkSoFar; |
| + private boolean isIdle; |
| + |
| + /** |
| + * Creates a new WatermarkOutput against the given DataOutput. |
| + */ |
| + public WatermarkToDataOutput(PushingAsyncDataInput.DataOutput<?> output) { |
| + this.output = checkNotNull(output); |
| + this.maxWatermarkSoFar = Long.MIN_VALUE; |
| + } |
| + |
| + @Override |
| + public void emitWatermark(Watermark watermark) { |
| + final long newWatermark = watermark.getTimestamp(); |
| + if (newWatermark <= maxWatermarkSoFar) { |
| + return; |
| + } |
| + |
| + maxWatermarkSoFar = newWatermark; |
| + |
| + try { |
| + if (isIdle) { |
| + output.emitStreamStatus(StreamStatus.ACTIVE); |
| + isIdle = false; |
| + } |
| + |
| + output.emitWatermark(new org.apache.flink.streaming.api.watermark.Watermark(newWatermark)); |
| + } catch (ExceptionInChainedOperatorException e) { |
| + throw e; |
| + } catch (Exception e) { |
| + throw new ExceptionInChainedOperatorException(e); |
| + } |
| + } |
| + |
| + @Override |
| + public void markIdle() { |
| + if (isIdle) { |
| + return; |
| + } |
| + |
| + try { |
| + output.emitStreamStatus(StreamStatus.IDLE); |
| + isIdle = true; |
| + } catch (ExceptionInChainedOperatorException e) { |
| + throw e; |
| + } catch (Exception e) { |
| + throw new ExceptionInChainedOperatorException(e); |
| + } |
| + } |
| +} |
| |
| |
| |
| |
| @@ -25,6 +25,7 @@ import org.apache.flink.annotation.Internal; |
| * {@link ProcessingTimeService}. |
| */ |
| @Internal |
| +@FunctionalInterface |
| public interface ProcessingTimeCallback { |
| |
| /** |
| |
| |
| |
| |
| @@ -19,6 +19,7 @@ package org.apache.flink.streaming.runtime.tasks; |
| |
| import java.util.concurrent.CompletableFuture; |
| import java.util.concurrent.ScheduledFuture; |
| +import java.util.concurrent.TimeUnit; |
| |
| /** |
| * Defines the current processing time and handles all related actions, |
| @@ -48,6 +49,9 @@ public interface ProcessingTimeService { |
| /** |
| * Registers a task to be executed repeatedly at a fixed rate. |
| * |
| + * <p>This call behaves similar to |
| + * {@link org.apache.flink.runtime.concurrent.ScheduledExecutor#scheduleAtFixedRate(Runnable, long, long, TimeUnit)}. |
| + * |
| * @param callback to be executed after the initial delay and then after each period |
| * @param initialDelay initial delay to start executing callback |
| * @param period after the initial delay after which the callback is executed |
| @@ -55,6 +59,19 @@ public interface ProcessingTimeService { |
| */ |
| ScheduledFuture<?> scheduleAtFixedRate(ProcessingTimeCallback callback, long initialDelay, long period); |
| |
| + /** |
| + * Registers a task to be executed repeatedly with a fixed delay. |
| + * |
| + * <p>This call behaves similar to |
| + * {@link org.apache.flink.runtime.concurrent.ScheduledExecutor#scheduleWithFixedDelay(Runnable, long, long, TimeUnit)}. |
| + * |
| + * @param callback to be executed after the initial delay and then after each period |
| + * @param initialDelay initial delay to start executing callback |
| + * @param period after the initial delay after which the callback is executed |
| + * @return Scheduled future representing the task to be executed repeatedly |
| + */ |
| + ScheduledFuture<?> scheduleWithFixedDelay(ProcessingTimeCallback callback, long initialDelay, long period); |
| + |
| /** |
| * This method puts the service into a state where it does not register new timers, but |
| * returns for each call to {@link #registerTimer} or {@link #scheduleAtFixedRate} a "mock" |
| |
| |
| |
| |
| @@ -76,6 +76,16 @@ class ProcessingTimeServiceImpl implements ProcessingTimeService { |
| addQuiesceProcessingToCallback(processingTimeCallbackWrapper.apply(callback)), initialDelay, period); |
| } |
| |
| + @Override |
| + public ScheduledFuture<?> scheduleWithFixedDelay(ProcessingTimeCallback callback, long initialDelay, long period) { |
| + if (isQuiesced()) { |
| + return new NeverCompleteFuture(initialDelay); |
| + } |
| + |
| + return timerService.scheduleWithFixedDelay( |
| + addQuiesceProcessingToCallback(processingTimeCallbackWrapper.apply(callback)), initialDelay, period); |
| + } |
| + |
| @Override |
| public CompletableFuture<Void> quiesce() { |
| if (!quiesced) { |
| |
| |
| |
| |
| @@ -19,7 +19,6 @@ |
| package org.apache.flink.streaming.runtime.tasks; |
| |
| import org.apache.flink.annotation.Internal; |
| -import org.apache.flink.api.connector.source.SourceOutput; |
| import org.apache.flink.runtime.execution.Environment; |
| import org.apache.flink.streaming.api.operators.Output; |
| import org.apache.flink.streaming.api.operators.SourceOperator; |
| @@ -31,7 +30,6 @@ import org.apache.flink.streaming.runtime.io.StreamTaskInput; |
| import org.apache.flink.streaming.runtime.io.StreamTaskSourceInput; |
| import org.apache.flink.streaming.runtime.streamrecord.LatencyMarker; |
| import org.apache.flink.streaming.runtime.streamrecord.StreamRecord; |
| -import org.apache.flink.streaming.runtime.streamstatus.StreamStatus; |
| import org.apache.flink.streaming.runtime.streamstatus.StreamStatusMaintainer; |
| |
| import static org.apache.flink.util.Preconditions.checkNotNull; |
| @@ -49,7 +47,7 @@ public class SourceOperatorStreamTask<T> extends StreamTask<T, SourceOperator<T, |
| @Override |
| public void init() { |
| StreamTaskInput<T> input = new StreamTaskSourceInput<>(headOperator); |
| - DataOutput<T> output = new StreamTaskSourceOutput<>( |
| + DataOutput<T> output = new AsyncDataOutputToOutput<>( |
| operatorChain.getChainEntryPoint(), |
| getStreamStatusMaintainer()); |
| |
| @@ -60,14 +58,13 @@ public class SourceOperatorStreamTask<T> extends StreamTask<T, SourceOperator<T, |
| } |
| |
| /** |
| - * Implementation of {@link DataOutput} that wraps a specific {@link Output} to emit |
| - * stream elements for {@link SourceOperator}. |
| + * Implementation of {@link DataOutput} that wraps a specific {@link Output}. |
| */ |
| - private static class StreamTaskSourceOutput<T> extends AbstractDataOutput<T> implements SourceOutput<T> { |
| + private static class AsyncDataOutputToOutput<T> extends AbstractDataOutput<T> { |
| |
| private final Output<StreamRecord<T>> output; |
| |
| - StreamTaskSourceOutput( |
| + AsyncDataOutputToOutput( |
| Output<StreamRecord<T>> output, |
| StreamStatusMaintainer streamStatusMaintainer) { |
| super(streamStatusMaintainer); |
| @@ -89,27 +86,5 @@ public class SourceOperatorStreamTask<T> extends StreamTask<T, SourceOperator<T, |
| public void emitWatermark(Watermark watermark) { |
| output.emitWatermark(watermark); |
| } |
| - |
| - // ------------------- methods from SourceOutput ------------- |
| - |
| - @Override |
| - public void collect(T record) throws Exception { |
| - output.collect(new StreamRecord<>(record)); |
| - } |
| - |
| - @Override |
| - public void collect(T record, long timestamp) throws Exception { |
| - output.collect(new StreamRecord<>(record, timestamp)); |
| - } |
| - |
| - @Override |
| - public void emitWatermark(org.apache.flink.api.common.eventtime.Watermark watermark) { |
| - output.emitWatermark(new Watermark(watermark.getTimestamp())); |
| - } |
| - |
| - @Override |
| - public void markIdle() { |
| - emitStreamStatus(StreamStatus.IDLE); |
| - } |
| } |
| } |
| |
| |
| |
| |
| @@ -126,16 +126,24 @@ public class SystemProcessingTimeService implements TimerService { |
| |
| @Override |
| public ScheduledFuture<?> scheduleAtFixedRate(ProcessingTimeCallback callback, long initialDelay, long period) { |
| - long nextTimestamp = getCurrentProcessingTime() + initialDelay; |
| + return scheduleRepeatedly(callback, initialDelay, period, false); |
| + } |
| + |
| + @Override |
| + public ScheduledFuture<?> scheduleWithFixedDelay(ProcessingTimeCallback callback, long initialDelay, long period) { |
| + return scheduleRepeatedly(callback, initialDelay, period, true); |
| + } |
| + |
| + private ScheduledFuture<?> scheduleRepeatedly(ProcessingTimeCallback callback, long initialDelay, long period, boolean fixedDelay) { |
| + final long nextTimestamp = getCurrentProcessingTime() + initialDelay; |
| + final Runnable task = wrapOnTimerCallback(callback, nextTimestamp, period); |
| |
| // we directly try to register the timer and only react to the status on exception |
| // that way we save unnecessary volatile accesses for each timer |
| try { |
| - return timerService.scheduleAtFixedRate( |
| - wrapOnTimerCallback(callback, nextTimestamp, period), |
| - initialDelay, |
| - period, |
| - TimeUnit.MILLISECONDS); |
| + return fixedDelay |
| + ? timerService.scheduleWithFixedDelay(task, initialDelay, period, TimeUnit.MILLISECONDS) |
| + : timerService.scheduleAtFixedRate(task, initialDelay, period, TimeUnit.MILLISECONDS); |
| } catch (RejectedExecutionException e) { |
| final int status = this.status.get(); |
| if (status == STATUS_QUIESCED) { |
| |
| |
| |
| |
| @@ -112,6 +112,12 @@ public class TestProcessingTimeService implements TimerService { |
| return periodicCallbackTask; |
| } |
| |
| + @Override |
| + public ScheduledFuture<?> scheduleWithFixedDelay(ProcessingTimeCallback callback, long initialDelay, long period) { |
| + // for all testing purposed, there is no difference between the fixed rate and fixed delay |
| + return scheduleAtFixedRate(callback, initialDelay, period); |
| + } |
| + |
| @Override |
| public boolean isTerminated() { |
| return isTerminated; |
|
|
