Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Remove unused methods in IexecHubService #572

Merged
merged 2 commits into from
Apr 18, 2023
Merged

Remove unused methods in IexecHubService #572

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
9220fb3
Remove unused methods in `IexecHubService`
jbern0rd Apr 18, 2023
1ce18a7
Update CHANGELOG.md
jbern0rd Apr 18, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions CHANGELOG.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,7 @@ All notable changes to this project will be documented in this file.
### Bug Fixes
- Prevent race condition on replicate update. (#568)
### Quality
- Remove unused methods in `IexecHubService`. (#572)
### Dependency Upgrades
- Upgrade to `iexec-common` 8.0.0. (#571)
- Add new `iexec-commons-poco` 1.0.2 dependency. (#571)
Expand Down
147 changes: 0 additions & 147 deletions src/main/java/com/iexec/core/chain/IexecHubService.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,19 +18,12 @@

import com.iexec.commons.poco.chain.*;
import com.iexec.commons.poco.contract.generated.IexecHubContract;
import com.iexec.commons.poco.utils.BytesUtils;
import io.reactivex.Flowable;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.tuple.Pair;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.web3j.protocol.core.RemoteCall;
import org.web3j.protocol.core.methods.request.EthFilter;
import org.web3j.protocol.core.methods.response.BaseEventResponse;
import org.web3j.protocol.core.methods.response.TransactionReceipt;

import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.List;
import java.util.Optional;
Expand All @@ -40,8 +33,6 @@
import java.util.concurrent.ThreadPoolExecutor;

import static com.iexec.common.utils.DateTimeUtils.now;
import static com.iexec.commons.poco.chain.ChainTaskStatus.ACTIVE;
import static com.iexec.commons.poco.chain.ChainTaskStatus.COMPLETED;
import static com.iexec.commons.poco.utils.BytesUtils.stringToBytes;

@Slf4j
Expand All @@ -52,7 +43,6 @@ public class IexecHubService extends IexecHubAbstractService {
private final CredentialsService credentialsService;
private final Web3jService web3jService;

@Autowired
public IexecHubService(CredentialsService credentialsService,
Web3jService web3jService,
ChainConfig chainConfig) {
Expand All @@ -68,22 +58,6 @@ public IexecHubService(CredentialsService credentialsService,
}
}

/**
* Check if a deal's task can be initialized.
* An initializable task should have the status
* UNSET onchain and have a contribution deadline
* that is still in the future.
*
* @param chainDealId
* @param taskIndex
* @return true if the task is initializable, false otherwise.
*/
public boolean isInitializableOnchain(String chainDealId, int taskIndex) {
boolean isTaskUnsetOnChain = isTaskInUnsetStatusOnChain(chainDealId, taskIndex);
boolean isBeforeContributionDeadline = isBeforeContributionDeadline(chainDealId);
return isBeforeContributionDeadline && isTaskUnsetOnChain;
}

/**
* Check if the task is defined onchain and
* has the status {@link ChainTaskStatus#UNSET}.
Expand Down Expand Up @@ -167,52 +141,6 @@ public Date getChainDealFinalDeadline(ChainDeal chainDeal) {
return new Date(startTime + maxTime * 10);
}

@Deprecated
public Optional<Pair<String, ChainReceipt>> initialize(String chainDealId, int taskIndex) {
log.info("Requested initialize [chainDealId:{}, taskIndex:{}, waitingTxCount:{}]", chainDealId, taskIndex, getWaitingTransactionCount());
try {
return CompletableFuture.supplyAsync(() -> sendInitializeTransaction(chainDealId, taskIndex), executor).get();
} catch (InterruptedException | ExecutionException e) {
log.error("initialize asynchronous execution did not complete", e);
}
return Optional.empty();
}

private Optional<Pair<String, ChainReceipt>> sendInitializeTransaction(String chainDealId, int taskIndex) {
byte[] chainDealIdBytes = stringToBytes(chainDealId);
String computedChainTaskId = ChainUtils.generateChainTaskId(chainDealId, taskIndex);
RemoteCall<TransactionReceipt> initializeCall =
getHubContract(web3jService.getWritingContractGasProvider())
.initialize(chainDealIdBytes, BigInteger.valueOf(taskIndex));

TransactionReceipt initializeReceipt;
try {
initializeReceipt = initializeCall.send();
} catch (Exception e) {
log.error("Failed to send initialize [chainDealId:{}, taskIndex:{}]", chainDealId, taskIndex, e);
return Optional.empty();
}

List<IexecHubContract.TaskInitializeEventResponse> initializeEvents = getHubContract().getTaskInitializeEvents(initializeReceipt);

IexecHubContract.TaskInitializeEventResponse initializeEvent = null;
if (initializeEvents != null && !initializeEvents.isEmpty()) {
initializeEvent = initializeEvents.get(0);
}

if (isSuccessTx(computedChainTaskId, initializeEvent, ACTIVE)) {
String chainTaskId = BytesUtils.bytesToString(initializeEvent.taskid);
ChainReceipt chainReceipt = buildChainReceipt(initializeReceipt);
log.info("Initialized [chainTaskId:{}, chainDealId:{}, taskIndex:{}, gasUsed:{}, block:{}]",
computedChainTaskId, chainDealId, taskIndex,
initializeReceipt.getGasUsed(), chainReceipt.getBlockNumber());
return Optional.of(Pair.of(chainTaskId, chainReceipt));
}

log.error("Failed to initialize [chainDealId:{}, taskIndex:{}]", chainDealId, taskIndex);
return Optional.empty();
}

public boolean canFinalize(String chainTaskId) {
Optional<ChainTask> optional = getChainTask(chainTaskId);
if (optional.isEmpty()) {
Expand All @@ -236,73 +164,6 @@ public boolean canFinalize(String chainTaskId) {
return ret;
}

public Optional<ChainReceipt> finalizeTask(String chainTaskId, String resultLink, String callbackData) {
log.info("Requested finalize [chainTaskId:{}, waitingTxCount:{}]", chainTaskId, getWaitingTransactionCount());
try {
return CompletableFuture.supplyAsync(() -> sendFinalizeTransaction(chainTaskId, resultLink, callbackData), executor).get();
} catch (InterruptedException | ExecutionException e) {
log.error("finalizeTask asynchronous execution did not complete", e);
}
return Optional.empty();
}

private Optional<ChainReceipt> sendFinalizeTransaction(String chainTaskId, String resultLink, String callbackData) {
byte[] chainTaskIdBytes = stringToBytes(chainTaskId);
byte[] results = new byte[0];
byte[] resultsCallback = new byte[0];

boolean shouldSendCallback = callbackData != null && !callbackData.isEmpty();
if (!shouldSendCallback) {
results = resultLink.getBytes(StandardCharsets.UTF_8);
} else {
resultsCallback = stringToBytes(callbackData);
}

TransactionReceipt finalizeReceipt;

RemoteCall<TransactionReceipt> finalizeCall = getHubContract(web3jService.getWritingContractGasProvider())
.finalize(chainTaskIdBytes, results, resultsCallback);

try {
finalizeReceipt = finalizeCall.send();
} catch (Exception e) {
log.error("Failed to send finalize [chainTaskId:{}, resultLink:{}, callbackData:{}, shouldSendCallback:{}]",
chainTaskId, resultLink, callbackData, shouldSendCallback, e);
return Optional.empty();
}

List<IexecHubContract.TaskFinalizeEventResponse> finalizeEvents = getHubContract().getTaskFinalizeEvents(finalizeReceipt);

IexecHubContract.TaskFinalizeEventResponse finalizeEvent = null;
if (finalizeEvents != null && !finalizeEvents.isEmpty()) {
finalizeEvent = finalizeEvents.get(0);
}

if (isSuccessTx(chainTaskId, finalizeEvent, COMPLETED)) {
ChainReceipt chainReceipt = buildChainReceipt(finalizeReceipt);
log.info("Finalized [chainTaskId:{}, resultLink:{}, callbackData:{}, " +
"shouldSendCallback:{}, gasUsed:{}, block:{}]",
chainTaskId, resultLink, callbackData, shouldSendCallback,
finalizeReceipt.getGasUsed(), chainReceipt.getBlockNumber());
return Optional.of(chainReceipt);
}

log.error("Failed to finalize [chainTaskId:{}]", chainTaskId);
return Optional.empty();
}

private boolean isSuccessTx(String chainTaskId, BaseEventResponse txEvent, ChainTaskStatus pretendedStatus) {
if (txEvent == null || txEvent.log == null) {
return false;
}

if (txEvent.log.getType() == null || txEvent.log.getType().equals(PENDING_RECEIPT_STATUS)) {
return isStatusValidOnChainAfterPendingReceipt(chainTaskId, pretendedStatus, this::isTaskStatusValidOnChain);
}

return true;
}

public boolean canReopen(String chainTaskId) {
Optional<ChainTask> optional = getChainTask(chainTaskId);
if (optional.isEmpty()) {
Expand Down Expand Up @@ -371,14 +232,6 @@ public boolean hasEnoughGas() {
return hasEnoughGas(credentialsService.getCredentials().getAddress());
}

private Boolean isTaskStatusValidOnChain(String chainTaskId, ChainStatus chainTaskStatus) {
if (chainTaskStatus instanceof ChainTaskStatus) {
Optional<ChainTask> optionalChainTask = getChainTask(chainTaskId);
return optionalChainTask.isPresent() && optionalChainTask.get().getStatus().equals(chainTaskStatus);
}
return false;
}

private ChainReceipt buildChainReceipt(TransactionReceipt receipt) {
return ChainReceipt.builder()
.txHash(receipt.getTransactionHash())
Expand Down