From fdd223c05f1fd2b7f5060f2224e04aff1287a434 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Fri, 3 May 2024 13:49:24 +0200 Subject: [PATCH 01/27] Update Docker image repository URLs (#506) * Update Docker image repository URLs in values.yaml * Update workflows * Updating tag --------- Co-authored-by: ausias-armesto --- .github/workflows/gcp-tag-artifact.yaml | 17 ++++++------ .github/workflows/main.yaml | 36 ++++++++++++++++--------- helm/ctdapp/values.yaml | 8 +++--- 3 files changed, 35 insertions(+), 26 deletions(-) diff --git a/.github/workflows/gcp-tag-artifact.yaml b/.github/workflows/gcp-tag-artifact.yaml index c3aced97..efb9a3a9 100644 --- a/.github/workflows/gcp-tag-artifact.yaml +++ b/.github/workflows/gcp-tag-artifact.yaml @@ -14,31 +14,30 @@ jobs: - name: Checkout repository uses: actions/checkout@v2 - - name: Set up Google Cloud credentials_json + - name: Set up Google Cloud Credentials id: auth - uses: google-github-actions/auth@v1 + uses: google-github-actions/auth@v2 with: token_format: "access_token" - credentials_json: ${{ secrets.GOOGLE_CTDAPP_SERVICE_ACCOUNT_CREDENTIALS }} + credentials_json: ${{ secrets.GOOGLE_HOPRASSOCIATION_CREDENTIALS_REGISTRY }} - name: Set up Google Cloud SDK - uses: google-github-actions/setup-gcloud@v1 + uses: google-github-actions/setup-gcloud@v2 with: - project_id: ${{ secrets.GOOGLE_PROJECT }} + project_id: hoprassociation install_components: beta - name: Login Google Container Registry uses: docker/login-action@v3 with: - registry: ${{ secrets.GOOGLE_REGION }}-docker.pkg.dev + registry: europe-west3-docker.pkg.dev username: oauth2accesstoken password: ${{ steps.auth.outputs.access_token }} - - name: Apply tag to GCP artifact run: | - docker_registry=${{ secrets.GOOGLE_REGION }}-docker.pkg.dev - image=${{ secrets.GOOGLE_PROJECT }}/${{ secrets.GOOGLE_REPOSITORY }}/cover-traffic + docker_registry=europe-west3-docker.pkg.dev + image=hoprassociation/docker-images/cover-traffic commit_tag=$(git rev-parse --short "$GITHUB_SHA") tag=${{ github.ref_name }} diff --git a/.github/workflows/main.yaml b/.github/workflows/main.yaml index b892401f..032c15b0 100644 --- a/.github/workflows/main.yaml +++ b/.github/workflows/main.yaml @@ -52,19 +52,29 @@ jobs: shell: sh run: echo "SHORT_SHA=`echo ${{ github.event.pull_request.head.sha }} | cut -c1-7`" >> $GITHUB_ENV - - name: Login to GCP - id: gcloud - uses: elgohr/gcloud-login-action@v1 #TODO - v2 is bugged, unable to get outputs + - name: Set up Google Cloud Credentials + id: auth + uses: google-github-actions/auth@v2 with: - account_key: ${{ secrets.GOOGLE_CREDENTIALS }} + token_format: "access_token" + credentials_json: ${{ secrets.GOOGLE_HOPRASSOCIATION_CREDENTIALS_REGISTRY }} - - name: Build and push container image - uses: elgohr/Publish-Docker-Github-Action@v5 + - name: Set up Google Cloud SDK + uses: google-github-actions/setup-gcloud@v2 with: - workdir: "ct-app" - dockerfile: "./Dockerfile" - name: ${{ secrets.GOOGLE_PROJECT }}/${{ secrets.GOOGLE_REPOSITORY }}/cover-traffic - registry: ${{ secrets.GOOGLE_REGION }}-docker.pkg.dev - username: ${{ steps.gcloud.outputs.username }} - password: ${{ steps.gcloud.outputs.password }} - tags: "${{ env.SHORT_SHA }}" + project_id: hoprassociation + install_components: beta + + - name: Login Google Container Registry + uses: docker/login-action@v3 + with: + registry: europe-west3-docker.pkg.dev + username: oauth2accesstoken + password: ${{ steps.auth.outputs.access_token }} + + - name: Build container image + uses: docker/build-push-action@v5 + with: + push: true + context: ct-app + tags: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic:${{ env.SHORT_SHA }} diff --git a/helm/ctdapp/values.yaml b/helm/ctdapp/values.yaml index 318609ea..f58ccf64 100644 --- a/helm/ctdapp/values.yaml +++ b/helm/ctdapp/values.yaml @@ -3,13 +3,13 @@ ctdapp: image: core: - repository: europe-west6-docker.pkg.dev/ctdapp-391309/ctdapp/cover-traffic + repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic pullPolicy: Always - tag: ba586d0 + tag: f65697a postman: - repository: europe-west6-docker.pkg.dev/ctdapp-391309/ctdapp/cover-traffic + repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic pullPolicy: Always - tag: ba586d0 + tag: f65697a nameOverride: "" fullnameOverride: "" From 5f745a3db373eaa29cb13708acc2eba66ed7efbe Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Fri, 3 May 2024 13:53:36 +0200 Subject: [PATCH 02/27] Clean up deployment's helm files (#505) * Scale deployment * fix * Adding envVars * quote * scale down * changing properties * updated prod env variables * deploy core and postman * change bucket name * Upgrading * fix url * add url x * adding secret x * new metrics * changing * update safe secrets * increase concurrency to 5 * pointing to instance 0 of the RabbitMQ * fix pod name * change to static IP * updated to correct url * revert * Distributing auto-funding across different time-zones * Update configuration values for ctdapp in staging environment and default values * Update configuration values for ctdapp in staging environment and default values * Secrets updated --------- Co-authored-by: ausias-armesto --- helm/ctdapp/templates/configmap-core.yaml | 35 ++++++++++++ helm/ctdapp/templates/configmap-postman.yaml | 5 ++ helm/ctdapp/templates/deployment-core.yaml | 4 +- helm/ctdapp/templates/deployment-postman.yaml | 4 +- helm/ctdapp/values.yaml | 1 - helm/secrets-staging.sops.yaml | 9 ++-- helm/values-prod.yaml | 53 ++----------------- helm/values-staging.yaml | 12 ++++- 8 files changed, 66 insertions(+), 57 deletions(-) diff --git a/helm/ctdapp/templates/configmap-core.yaml b/helm/ctdapp/templates/configmap-core.yaml index 58a15ab0..a3c3f9cd 100644 --- a/helm/ctdapp/templates/configmap-core.yaml +++ b/helm/ctdapp/templates/configmap-core.yaml @@ -5,6 +5,41 @@ metadata: argocd.argoproj.io/sync-wave: "1" name: core-config data: + FLAG_CORE_HEALTHCHECK: "60" + FLAG_CORE_CHECK_SUBGRAPH_URLS: "200" + FLAG_CORE_GET_FUNDINGS: "900" + FLAG_CORE_GET_TICKET_PRICE: "900" + FLAG_CORE_AGGREGATE_PEERS: "300" + FLAG_CORE_GET_TOPOLOGY_DATA: "300" + FLAG_CORE_GET_SUBGRAPH_DATA: "300" + FLAG_CORE_GET_REGISTERED_NODES: "300" + FLAG_CORE_GET_NFT_HOLDERS: "900" + FLAG_CORE_APPLY_ECONOMIC_MODEL: "600" + + FLAG_NODE_HEALTHCHECK: "60" + FLAG_NODE_RETRIEVE_PEERS: "300" + FLAG_NODE_RETRIEVE_OUTGOING_CHANNELS: "600" + FLAG_NODE_RETRIEVE_INCOMING_CHANNELS: "600" + FLAG_NODE_RETRIEVE_BALANCES: "900" + FLAG_NODE_OPEN_CHANNELS: "900" + FLAG_NODE_CLOSE_OLD_CHANNELS: "900" + FLAG_NODE_CLOSE_PENDING_CHANNELS: "1800" + FLAG_NODE_FUND_CHANNELS: "900" + FLAG_NODE_GET_TOTAL_CHANNEL_FUNDS: "900" + + DISTRIBUTION_MIN_ELIGIBLE_PEERS: "100" + DISTRIBUTION_MAX_APR_PERCENTAGE: "15.0" + + PEER_MIN_VERSION: "2.0.7" + + GCP_FILE_PREFIX: expected_reward + GCP_FOLDER: expected_rewards + + ECONOMIC_MODEL_MIN_SAFE_ALLOWANCE: "-1" + ECONOMIC_MODEL_NFT_THRESHOLD: "-1" + + RABBITMQ_TASK_NAME: send_1_hop_message + RABBITMQ_PROJECT_NAME: ct-app {{- if .Values.ctdapp.core.extraEnvVars -}} {{ .Values.ctdapp.core.extraEnvVars | toYaml | nindent 2 }} {{- end }} \ No newline at end of file diff --git a/helm/ctdapp/templates/configmap-postman.yaml b/helm/ctdapp/templates/configmap-postman.yaml index f1b8372b..3f65f378 100644 --- a/helm/ctdapp/templates/configmap-postman.yaml +++ b/helm/ctdapp/templates/configmap-postman.yaml @@ -5,6 +5,11 @@ metadata: argocd.argoproj.io/sync-wave: "1" name: postman-config data: + PARAM_BATCH_SIZE: "200" + PARAM_DELAY_BETWEEN_TWO_MESSAGES: "0.2" + PARAM_MESSAGE_DELIVERY_TIMEOUT: "15" + PARAM_MAX_ATTEMPTS: "6" + RABBITMQ_PROJECT_NAME: ct-app {{- if .Values.ctdapp.postman.extraEnvVars -}} {{ .Values.ctdapp.postman.extraEnvVars | toYaml | nindent 2 }} {{- end }} \ No newline at end of file diff --git a/helm/ctdapp/templates/deployment-core.yaml b/helm/ctdapp/templates/deployment-core.yaml index 9f2ecf7c..86fb0814 100644 --- a/helm/ctdapp/templates/deployment-core.yaml +++ b/helm/ctdapp/templates/deployment-core.yaml @@ -28,8 +28,8 @@ spec: serviceAccountName: {{ include "ctdapp.serviceAccountName" . }} containers: - name: {{ .Chart.Name }} - image: "{{ .Values.ctdapp.image.core.repository }}:{{ .Values.ctdapp.image.core.tag }}" - imagePullPolicy: {{ .Values.ctdapp.image.core.pullPolicy }} + image: "{{ .Values.ctdapp.core.repository }}:{{ .Values.ctdapp.core.tag }}" + imagePullPolicy: {{ .Values.ctdapp.core.pullPolicy }} ports: - name: http containerPort: {{ .Values.ctdapp.service.port }} diff --git a/helm/ctdapp/templates/deployment-postman.yaml b/helm/ctdapp/templates/deployment-postman.yaml index fab09b78..1e342c81 100644 --- a/helm/ctdapp/templates/deployment-postman.yaml +++ b/helm/ctdapp/templates/deployment-postman.yaml @@ -28,8 +28,8 @@ spec: serviceAccountName: {{ include "ctdapp.serviceAccountName" . }} containers: - name: {{ .Chart.Name }} - image: "{{ .Values.ctdapp.image.postman.repository }}:{{ .Values.ctdapp.image.postman.tag }}" - imagePullPolicy: {{ .Values.ctdapp.image.postman.pullPolicy }} + image: "{{ .Values.ctdapp.postman.repository }}:{{ .Values.ctdapp.postman.tag }}" + imagePullPolicy: {{ .Values.ctdapp.postman.pullPolicy }} envFrom: - configMapRef: name: postman-config diff --git a/helm/ctdapp/values.yaml b/helm/ctdapp/values.yaml index f58ccf64..d5957a45 100644 --- a/helm/ctdapp/values.yaml +++ b/helm/ctdapp/values.yaml @@ -1,6 +1,5 @@ environmentName: "" ctdapp: - image: core: repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic diff --git a/helm/secrets-staging.sops.yaml b/helm/secrets-staging.sops.yaml index 5c242646..325c54f4 100644 --- a/helm/secrets-staging.sops.yaml +++ b/helm/secrets-staging.sops.yaml @@ -16,9 +16,12 @@ ctdapp: username: ENC[AES256_GCM,data:8kx+G5x7,iv:7Iuaab3j1P0Fa+zvvLk0KiaxiqA7gAR/c0L73o9u7CU=,tag:1AlE0bLsLKj1kKif3sB/eg==,type:str] virtualhost: ENC[AES256_GCM,data:quiqbqQN,iv:en9oeMNGGXM6oGwkX4KfnHhON/1NIQ2i5OFRAJO7NXQ=,tag:SdveTPa2Hr8JUo9ykl2ehg==,type:str] subgraph: + stakingUrl: ENC[AES256_GCM,data:UXoyoipM5CVDrvkSb5TVhUVnnUcb1Hfhz7QLH5UvIX+YgUShXwhL+KV/Hkp7CZhk2mPtML04P2RpFNyHx/X3bVINpC01C+vUBVGlsu8G3RkWYm3NZdcu6/EWlTcx5QGsLDg3F6LHmRMEiq6cYQ+kYmDo87e1ZByOOXUb,iv:yQqCJOqDnCEmHScL9IGR1AyVldofsSAEbInmH84kaas=,tag:xS32cZngQ5x5gJLBTads5A==,type:str] + stakingUrlBackup: ENC[AES256_GCM,data:1RFSxyDt+rjjyeBW54hga2UQJ3iyxiWFHSVmJ4KWbsyO7UCa3km0WWMM/RUy8WG1v3jMHMf0mnd6Lv5ROHAE4dWUm+8vV855wt8=,iv:iFiHu8MVDn0986OQqIRcqaUSAn6TZJBrsk+nfsP/ABM=,tag:aGMhZP03QYI5s4AjaiLksw==,type:str] safesBalanceUrl: ENC[AES256_GCM,data:7yp7I4/JKaWe/rKAndSV9RZjVRnnjrBz5S5Wc+Ju4+etrWmXNP+ZsSu0fqjus3p8vcF/RfCS2i15HLR+Bh8qISGRnVFAMOFHJYiIFqOIAefnGnGJIZTF5yTgMUhoY98dgq77XAuiqtTSDZQ4hmvpFemMM/L1sQFv+GjZ,iv:RcoYo91coC2lW3vDiPF0FTcM+FEC8J8lZ6TFNfZ/3D8=,tag:gTomJ1/hJKhYsASQOZvxZQ==,type:str] safesBalanceUrlBackup: ENC[AES256_GCM,data:oP6dVIxme8VAukzmhMTY3aCJTGiMtkKhK5Ext/857I3hiIsBhJ4Hv28/+Ys7X7jRdD0h4VnjCVByO3OSygeJAs1Sf9aBQuvCi4WYpQ==,iv:uZwldoiN+wADGtimX05+2/T8irp1O3OA9WyWHke538Y=,tag:f+dbpP/CEm56Xmg1B5PaiA==,type:str] - wxhporTxsUrl: ENC[AES256_GCM,data:dFClzw3WomvblSNcYPACXOU4p7Y+Hbp1lNrIxXPvU4wo39eg0S+SZeplhgQtCVDnOLrFo2B8TISmR2Dc+gXs8T6FfHkR,iv:21HVwIjtpDJppFUctm849EwMq3rZeEssBwwqnqcN/p8=,tag:kyo/GU+uBrupY9dAz5xefg==,type:str] + wxhoprTxsUrl: ENC[AES256_GCM,data:FirJ4hbxjMbou5o6K+0WVCwKYUPhmit+Iy88atrgtPaOYdXEhWzzs2zuIJ+ZnNXJElPMYr9KQf9Rhpn1AIt4drWH23URtfxMhsFZSguTT9CWX+qBnDXlx493LOFDBCufrAwYcXFOyey5AmDIO1WVEJxHfIoqgrrbHNk8,iv:bbHjIS6iCdB+mJ8935eIk0IRV9FJaSavQm/43hvh0/s=,tag:L8ioVhfx//fu2QQAUju9WQ==,type:str] + wxhoprTxsUrlBackup: ENC[AES256_GCM,data:zyc7R1s3EjnoxImzzB0QimkR/YTFp3JH0iy2qcKIhecosyYfXy+/KrHG6DhkFWVWzCmFZV81vmG9fRk2L1XK/kM2Yi1e,iv:+GwEL4ajYTG7OZTU1/kFFHQCMOwq1pUp+mWEvFsByTY=,tag:LoIzQTXVBwegd8faO6qJoQ==,type:str] sops: shamir_threshold: 1 kms: [] @@ -35,8 +38,8 @@ sops: U1Y1U3hub0Q1eVlWZS9HU3dYelpGbHcK8zlP32ezjRDORF9Z8OdKib/Hm0gdL4v5 oakH+9etUi3LoXowDza9ZocCwfgCjmx4WhKFCw/n3eRT0zBk4o+OaQ== -----END AGE ENCRYPTED FILE----- - lastmodified: "2024-04-11T15:07:37Z" - mac: ENC[AES256_GCM,data:lw4NEcxtTLxkCcE/ckn2uvCi7NJpFQVoR4bfWm6Nvul2g/b/5r1yoOzcIAiDuWHSG/WBPbSMAJfzefhonuu8smdxZh4U38aSTRSFI7RQlW67qBrRjOhBaUIQxQkn3UpSOYgIm/v+V/ErDhc4HtHieDqmH4OvWubMrANBiDzQyQQ=,iv:KmfzbtVxi2fkva2Den/U3tv9vkHelgKWjmtqClOaSLs=,tag:OUEfR8yWFEcqpSnyP70gPA==,type:str] + lastmodified: "2024-05-02T08:47:13Z" + mac: ENC[AES256_GCM,data:XYT2u/WfKcSAN7ymC6YRfGzHKly/HFkOjnBfLJr8lWXoWZrmjNdqMZD8YTVSk9sDAz1hqt+HPm7jNZxFezqqg+fosTwittpkJo/YPd2faZoCoZQF9N88YuIuOKZMc8fw88PdIUG/HRbPSbeWvYNsH3c+V0JFCAHH+KMv6ld4alk=,iv:zlmTLfZwbb+peP/RW9jUnSYecg/Z5ocRVsTANk7KRiU=,tag:tkjwriloWB9p3wqmc2WjrQ==,type:str] pgp: [] unencrypted_suffix: _unencrypted version: 3.8.0 diff --git a/helm/values-prod.yaml b/helm/values-prod.yaml index 6bfe79c7..50f7178f 100644 --- a/helm/values-prod.yaml +++ b/helm/values-prod.yaml @@ -6,66 +6,23 @@ green-nodes: enabled: false ctdapp: - image: - core: - tag: v2.1.10 - postman: - tag: v2.1.10 core: replicas: 1 + tag: v2.1.10 extraEnvVars: - FLAG_CORE_HEALTHCHECK: "60" - FLAG_CORE_CHECK_SUBGRAPH_URLS: "200" - FLAG_CORE_GET_FUNDINGS: "900" - FLAG_CORE_GET_TICKET_PRICE: "900" - FLAG_CORE_AGGREGATE_PEERS: "300" - FLAG_CORE_GET_TOPOLOGY_DATA: "300" - FLAG_CORE_GET_SUBGRAPH_DATA: "300" - FLAG_CORE_GET_REGISTERED_NODES: "300" - FLAG_CORE_GET_NFT_HOLDERS: "900" - FLAG_CORE_APPLY_ECONOMIC_MODEL: "600" FLAG_CORE_DISTRIBUTE_REWARDS: "1" - FLAG_NODE_HEALTHCHECK: "60" - FLAG_NODE_RETRIEVE_PEERS: "300" - FLAG_NODE_RETRIEVE_OUTGOING_CHANNELS: "600" - FLAG_NODE_RETRIEVE_INCOMING_CHANNELS: "600" - FLAG_NODE_RETRIEVE_BALANCES: "900" - FLAG_NODE_OPEN_CHANNELS: "900" - FLAG_NODE_CLOSE_OLD_CHANNELS: "900" - FLAG_NODE_CLOSE_PENDING_CHANNELS: "1800" - FLAG_NODE_FUND_CHANNELS: "900" - FLAG_NODE_GET_TOTAL_CHANNEL_FUNDS: "900" - - DISTRIBUTION_MIN_ELIGIBLE_PEERS: "100" + DISTRIBUTION_MIN_ELIGIBLE_PEERS: "5" DISTRIBUTION_MAX_APR_PERCENTAGE: "15.0" - - PEER_MIN_VERSION: "2.0.7" - - GCP_FILE_PREFIX: expected_reward - GCP_FOLDER: expected_rewards + GCP_BUCKET: hoprnet-ctdapp-prod ECONOMIC_MODEL_FILENAME: parameters-production.json - ECONOMIC_MODEL_MIN_SAFE_ALLOWANCE: "-1" - ECONOMIC_MODEL_NFT_THRESHOLD: "-1" + CHANNEL_MIN_BALANCE: "15" CHANNEL_FUNDING_AMOUNT: "50" CHANNEL_MAX_AGE_SECONDS: "172800" - - RABBITMQ_TASK_NAME: send_1_hop_message - RABBITMQ_PROJECT_NAME: ct-app - - LEGACY_SUBGRAPH_PAGINATION_SIZE: "1000" - LEGACY_SUBGRAPH_SAFES_BALANCE_QUERY: "{ safes(first: valfirst, skip: valskip) { registeredNodesInNetworkRegistry { node { id } safe { id balance { wxHoprBalance } allowance { wxHoprAllowance } } } } }" - LEGACY_SUBGRAPH_WXHOPR_TXS_QUERY: "{ transactions(where: { from: valfrom, to: valto }) { from to amount }} " - LEGACY_SUBGRAPH_FROM_ADDRESS: 0xd9a00176cf49dfb9ca3ef61805a2850f45cb1d05 postman: replicas: 1 - extraEnvVars: - PARAM_BATCH_SIZE: "200" - PARAM_DELAY_BETWEEN_TWO_MESSAGES: "0.2" - PARAM_MESSAGE_DELIVERY_TIMEOUT: "15" - PARAM_MAX_ATTEMPTS: "6" - RABBITMQ_PROJECT_NAME: ct-app \ No newline at end of file + tag: v2.1.10 \ No newline at end of file diff --git a/helm/values-staging.yaml b/helm/values-staging.yaml index 2d243529..782199d4 100644 --- a/helm/values-staging.yaml +++ b/helm/values-staging.yaml @@ -8,5 +8,15 @@ green-nodes: ctdapp: core: replicas: 0 + tag: ba586d0 + extraEnvVars: + GCP_BUCKET: hoprnet-ctdapp-staging + + ECONOMIC_MODEL_FILENAME: parameters-staging.json + + CHANNEL_MIN_BALANCE: "0.05" + CHANNEL_FUNDING_AMOUNT: "0.2" + CHANNEL_MAX_AGE_SECONDS: "172800" postman: - replicas: 0 \ No newline at end of file + replicas: 0 + tag: ba586d0 \ No newline at end of file From b2d47732473d3f1e1df61af48d84bcace2211143 Mon Sep 17 00:00:00 2001 From: ausias-armesto Date: Fri, 3 May 2024 14:30:15 +0200 Subject: [PATCH 03/27] Using latest --- .github/workflows/main.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yaml b/.github/workflows/main.yaml index 032c15b0..093d68a9 100644 --- a/.github/workflows/main.yaml +++ b/.github/workflows/main.yaml @@ -77,4 +77,4 @@ jobs: with: push: true context: ct-app - tags: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic:${{ env.SHORT_SHA }} + tags: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic:latest From 711b2a946efad2b798631c54e63e5d2e8494a3b8 Mon Sep 17 00:00:00 2001 From: ausias-armesto Date: Fri, 3 May 2024 14:55:35 +0200 Subject: [PATCH 04/27] Fixing pipeline tagging (#508) --- .github/workflows/main.yaml | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yaml b/.github/workflows/main.yaml index 093d68a9..c90848b3 100644 --- a/.github/workflows/main.yaml +++ b/.github/workflows/main.yaml @@ -50,7 +50,13 @@ jobs: - name: Calculate environment variables shell: sh - run: echo "SHORT_SHA=`echo ${{ github.event.pull_request.head.sha }} | cut -c1-7`" >> $GITHUB_ENV + run: | + commit_hash="${{ github.event.pull_request.head.sha }}" + if [ -z "${commit_hash}" ]; then + echo "docker_tag=latest" >> $GITHUB_ENV + else + echo "docker_tag=`echo ${commit_hash} | cut -c1-7`" >> $GITHUB_ENV + fi - name: Set up Google Cloud Credentials id: auth @@ -77,4 +83,4 @@ jobs: with: push: true context: ct-app - tags: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic:latest + tags: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic:${{ env.docker_tag }} From 91307e17c3dcf243382b3841f899084e8024fbe5 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Fri, 3 May 2024 15:35:24 +0200 Subject: [PATCH 05/27] Update Docker image repository URLs in values.yaml (#509) --- helm/ctdapp/values.yaml | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/helm/ctdapp/values.yaml b/helm/ctdapp/values.yaml index d5957a45..ec207296 100644 --- a/helm/ctdapp/values.yaml +++ b/helm/ctdapp/values.yaml @@ -1,14 +1,13 @@ environmentName: "" ctdapp: - image: - core: - repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic - pullPolicy: Always - tag: f65697a - postman: - repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic - pullPolicy: Always - tag: f65697a + core: + repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic + pullPolicy: Always + tag: f65697a + postman: + repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic + pullPolicy: Always + tag: f65697a nameOverride: "" fullnameOverride: "" From 59c6905969454a4de14cb790b11266f222aefa96 Mon Sep 17 00:00:00 2001 From: ausias-armesto Date: Fri, 3 May 2024 16:10:30 +0200 Subject: [PATCH 06/27] Move the repository into the correct child (#510) * Move the repository into the correct child * Fixing secret rabbitMQ --- helm/ctdapp/templates/secret-rabbitmq.yaml | 19 ++++++++++++++++--- helm/ctdapp/values.yaml | 15 ++++++--------- 2 files changed, 22 insertions(+), 12 deletions(-) diff --git a/helm/ctdapp/templates/secret-rabbitmq.yaml b/helm/ctdapp/templates/secret-rabbitmq.yaml index 80d526d4..dd76c824 100644 --- a/helm/ctdapp/templates/secret-rabbitmq.yaml +++ b/helm/ctdapp/templates/secret-rabbitmq.yaml @@ -1,9 +1,22 @@ +--- apiVersion: v1 kind: Secret metadata: - annotations: - argocd.argoproj.io/sync-wave: "1" - replicator.v1.mittwald.de/replicate-to: rabbitmq + name: rabbitmq-ctdapp + namespace: ctdapp +data: + CELERY_BROKER_URL: {{ .Values.ctdapp.rabbitmq.celeryBrokerUrl | b64enc }} + RABBITMQ_HOST: {{ .Values.ctdapp.rabbitmq.host | b64enc }} + RABBITMQ_PASSWORD: {{ .Values.ctdapp.rabbitmq.password | b64enc }} + RABBITMQ_USERNAME: {{ .Values.ctdapp.rabbitmq.username | b64enc }} + RABBITMQ_VIRTUALHOST: {{ .Values.ctdapp.rabbitmq.virtualhost | b64enc }} + password: {{ .Values.ctdapp.rabbitmq.password | b64enc }} + username: {{ .Values.ctdapp.rabbitmq.username | b64enc }} +--- +apiVersion: v1 +kind: Secret +metadata: + anamespace: rabbitmq name: rabbitmq-ctdapp data: CELERY_BROKER_URL: {{ .Values.ctdapp.rabbitmq.celeryBrokerUrl | b64enc }} diff --git a/helm/ctdapp/values.yaml b/helm/ctdapp/values.yaml index ec207296..600576e3 100644 --- a/helm/ctdapp/values.yaml +++ b/helm/ctdapp/values.yaml @@ -1,13 +1,5 @@ environmentName: "" ctdapp: - core: - repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic - pullPolicy: Always - tag: f65697a - postman: - repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic - pullPolicy: Always - tag: f65697a nameOverride: "" fullnameOverride: "" @@ -33,6 +25,9 @@ ctdapp: core: + repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic + pullPolicy: Always + tag: "" replicas: 1 extraEnvVars: {} resources: @@ -42,8 +37,10 @@ ctdapp: requests: cpu: 250m memory: 256Mi - postman: + repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic + pullPolicy: Always + tag: "" replicas: 1 extraEnvVars: {} resources: From c28dc2a8cdd1df7222c63600c6515c9ec56542a2 Mon Sep 17 00:00:00 2001 From: ausias-armesto Date: Fri, 3 May 2024 16:15:48 +0200 Subject: [PATCH 07/27] Fix typo in namespace (#511) --- helm/ctdapp/templates/secret-rabbitmq.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/helm/ctdapp/templates/secret-rabbitmq.yaml b/helm/ctdapp/templates/secret-rabbitmq.yaml index dd76c824..283bff57 100644 --- a/helm/ctdapp/templates/secret-rabbitmq.yaml +++ b/helm/ctdapp/templates/secret-rabbitmq.yaml @@ -16,7 +16,7 @@ data: apiVersion: v1 kind: Secret metadata: - anamespace: rabbitmq + namespace: rabbitmq name: rabbitmq-ctdapp data: CELERY_BROKER_URL: {{ .Values.ctdapp.rabbitmq.celeryBrokerUrl | b64enc }} From f61036ef4f07318ec5db163359ed66c539b823e1 Mon Sep 17 00:00:00 2001 From: ausias-armesto Date: Wed, 8 May 2024 14:32:16 +0200 Subject: [PATCH 08/27] Upgrade to make it work for new version of hoprd-operator (#513) --- helm/helmfile.yaml | 4 ++-- helm/values-common.yaml | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/helm/helmfile.yaml b/helm/helmfile.yaml index 5fd3b3ea..a1f2da76 100644 --- a/helm/helmfile.yaml +++ b/helm/helmfile.yaml @@ -49,7 +49,7 @@ releases: namespace: ctdapp chart: hoprassociation/cluster-hoprd condition: blue-nodes.enabled - version: 0.3.0 + version: 0.3.1 wait: true timeout: 5 values: @@ -62,7 +62,7 @@ releases: namespace: ctdapp chart: hoprassociation/cluster-hoprd condition: green-nodes.enabled - version: 0.3.0 + version: 0.3.1 wait: true timeout: 5 values: diff --git a/helm/values-common.yaml b/helm/values-common.yaml index 31735460..2b051ea1 100644 --- a/helm/values-common.yaml +++ b/helm/values-common.yaml @@ -1,11 +1,11 @@ deployment: resources: | limits: - cpu: 1500m - memory: 3Gi + cpu: 2000m + memory: 2Gi requests: - cpu: 750m - memory: 1G + cpu: 250m + memory: 250Mi startupProbe: | failureThreshold: 800 httpGet: From 930e8a530c19ed317a6f31669a6b330e194cbc2c Mon Sep 17 00:00:00 2001 From: ausias-armesto Date: Wed, 8 May 2024 14:39:04 +0200 Subject: [PATCH 09/27] Upgrade clusterhoprd helm chart (#514) * Upgrade to make it work for new version of hoprd-operator * Upgrade version --- helm/helmfile.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/helm/helmfile.yaml b/helm/helmfile.yaml index a1f2da76..b38463e0 100644 --- a/helm/helmfile.yaml +++ b/helm/helmfile.yaml @@ -36,7 +36,7 @@ releases: namespace: ctdapp chart: hoprassociation/cluster-hoprd condition: legacy-nodes.enabled - version: 0.3.0 + version: 0.3.1 wait: true timeout: 5 values: From 61357f9595dcaf2053cccc69d263960a4deaac47 Mon Sep 17 00:00:00 2001 From: ausias-armesto Date: Mon, 13 May 2024 18:06:06 +0200 Subject: [PATCH 10/27] Upgrade to version "saint-louis" (#515) --- helm/values-staging-blue.yaml | 2 +- helm/values-staging-green.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/helm/values-staging-blue.yaml b/helm/values-staging-blue.yaml index 332de830..f67622bd 100644 --- a/helm/values-staging-blue.yaml +++ b/helm/values-staging-blue.yaml @@ -1,6 +1,6 @@ replicas: 5 network: rotsee -version: 2.1.0-rc.4-pr.6206 +version: saint-louis config: | hopr: diff --git a/helm/values-staging-green.yaml b/helm/values-staging-green.yaml index c5dcca77..10f9a3bb 100644 --- a/helm/values-staging-green.yaml +++ b/helm/values-staging-green.yaml @@ -1,6 +1,6 @@ replicas: 0 network: rotsee -version: 2.1.0-rc.3 +version: saint-louis config: | hopr: From e1b4c0c8bd7a04e2ea0e63bb04a96a94b69bc469 Mon Sep 17 00:00:00 2001 From: ausias-armesto Date: Tue, 14 May 2024 21:54:20 +0200 Subject: [PATCH 11/27] Create automatic database backups (#516) * Create automatic database backups * remove character * rename backup --- helm/ctdapp/templates/cronjob-backup.yaml | 55 +++++++++++++++++++ .../templates/serviceaccount-backup.yaml | 10 ++++ helm/ctdapp/values.yaml | 3 + helm/values-prod.yaml | 4 ++ helm/values-staging.yaml | 4 ++ 5 files changed, 76 insertions(+) create mode 100644 helm/ctdapp/templates/cronjob-backup.yaml create mode 100644 helm/ctdapp/templates/serviceaccount-backup.yaml diff --git a/helm/ctdapp/templates/cronjob-backup.yaml b/helm/ctdapp/templates/cronjob-backup.yaml new file mode 100644 index 00000000..f7cf3923 --- /dev/null +++ b/helm/ctdapp/templates/cronjob-backup.yaml @@ -0,0 +1,55 @@ +--- +{{- if .Values.backup.enabled }} +apiVersion: batch/v1 +kind: CronJob +metadata: + name: ctdapp-backup +spec: + concurrencyPolicy: Forbid + successfulJobsHistoryLimit: 1 + failedJobsHistoryLimit: 2 + schedule: "{{ .Values.backup.schedule }}" + jobTemplate: + spec: + backoffLimit: 0 + ttlSecondsAfterFinished: 3600 + template: + spec: + initContainers: + - name: dump + image: postgres:15-bookworm + command: + - /bin/bash + - -c + - | + set -e + TIMESTAMP=$(date +%Y%m%d%H%M%S) + echo Starting full backup of database ${PGDATABASE} at $(date) + pg_dump --no-privileges --no-owner --format=custom --compress=9 --file=/backup/ctdapp-${TIMESTAMP}.dump + echo Backup finished at $(date) + envFrom: + - secretRef: + name: postgres + volumeMounts: + - name: backup + mountPath: /backup + containers: + - name: backup + image: gcr.io/google.com/cloudsdktool/google-cloud-cli:475.0.0 + command: + - /bin/bash + - -c + - | + echo Copying the backup to the bucket + gsutil cp /backup/*.dump gs://hoprnet-backup-{{ .Values.environmentName }}/postgres/ctdapp/ + echo Keep only the 7 most recent backups + gsutil ls gs://hoprnet-backup-{{ .Values.environmentName }}/postgres/ctdapp | sort -r | tail -n +8 | xargs -I {} gsutil rm {} + volumeMounts: + - name: backup + mountPath: /backup + volumes: + - name: backup + emptyDir: {} + restartPolicy: OnFailure + serviceAccount: sa-backup +{{- end }} diff --git a/helm/ctdapp/templates/serviceaccount-backup.yaml b/helm/ctdapp/templates/serviceaccount-backup.yaml new file mode 100644 index 00000000..7149105b --- /dev/null +++ b/helm/ctdapp/templates/serviceaccount-backup.yaml @@ -0,0 +1,10 @@ +--- +{{- if .Values.backup.enabled }} +apiVersion: v1 +automountServiceAccountToken: true +kind: ServiceAccount +metadata: + name: sa-backup + annotations: + iam.gke.io/gcp-service-account: "backup@hopr-{{ .Values.environmentName }}.iam.gserviceaccount.com" +{{- end }} diff --git a/helm/ctdapp/values.yaml b/helm/ctdapp/values.yaml index 600576e3..6c8ef31c 100644 --- a/helm/ctdapp/values.yaml +++ b/helm/ctdapp/values.yaml @@ -1,4 +1,7 @@ environmentName: "" +backup: + enabled: false + schedule: ctdapp: nameOverride: "" diff --git a/helm/values-prod.yaml b/helm/values-prod.yaml index 50f7178f..fbe8b968 100644 --- a/helm/values-prod.yaml +++ b/helm/values-prod.yaml @@ -5,6 +5,10 @@ blue-nodes: green-nodes: enabled: false +backup: + enabled: true + schedule: 30 21 * * * # 9:30 PM UTC + ctdapp: core: replicas: 1 diff --git a/helm/values-staging.yaml b/helm/values-staging.yaml index 782199d4..5c0ad62a 100644 --- a/helm/values-staging.yaml +++ b/helm/values-staging.yaml @@ -5,6 +5,10 @@ blue-nodes: green-nodes: enabled: true +backup: + enabled: true + schedule: 30 21 * * * # 9:30 PM UTC + ctdapp: core: replicas: 0 From 65da931114e245c23e4fc77e4d1edae1848fbf72 Mon Sep 17 00:00:00 2001 From: ausias-armesto Date: Thu, 16 May 2024 15:02:20 +0200 Subject: [PATCH 12/27] Add documentation on how to connect to database (#517) * Add documentation on how to connect to database * Update helm/README.md Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --------- Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- helm/README.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 helm/README.md diff --git a/helm/README.md b/helm/README.md new file mode 100644 index 00000000..26d6a984 --- /dev/null +++ b/helm/README.md @@ -0,0 +1,14 @@ +# ctdApp Deployment docs + +## Connect to Database + +```bash +gcloud compute instances start --project=hopr-prod --zone=europe-west3-a bastion +gcloud compute ssh bastion --zone=europe-west3-a --project=hopr-prod -- -L 5432:localhost:5432 +export PGHOST=localhost +export PGPORT=5432 +export PGDATABASE=ctdapp +export PGUSER=ctdapp +export PGPASSWORD=`Get from Bitwarden secret "ctdApp - Postgres Production"` +psql +``` From 71f60031b68dbd259f5f464806ff4e7c79a22542 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Mon, 20 May 2024 23:01:23 +0200 Subject: [PATCH 13/27] chore: Handle additional error cases in GraphQLProvider (#518) --- ct-app/core/components/graphql_providers.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ct-app/core/components/graphql_providers.py b/ct-app/core/components/graphql_providers.py index b8304d6e..9236390a 100644 --- a/ct-app/core/components/graphql_providers.py +++ b/ct-app/core/components/graphql_providers.py @@ -42,6 +42,10 @@ async def _execute(self, query: DocumentNode, variable_values: dict): raise ProviderError(err.errors[0]["message"]) except TimeoutError as err: self.error(f"Timeout error: {err}") + except ProviderError as err: + self.error(f"ProviderError error: {err}") + except Exception as err: + self.error(f"Unknown error: {err}") async def _test_query(self, key: str, **kwargs) -> bool: """ From bf07f1c8e9adebe02e17749493d4f41a4be567c9 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Tue, 21 May 2024 11:51:38 +0200 Subject: [PATCH 14/27] Fix catch provider error gql (#519) --- ct-app/core/components/graphql_providers.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/ct-app/core/components/graphql_providers.py b/ct-app/core/components/graphql_providers.py index 9236390a..fe42462a 100644 --- a/ct-app/core/components/graphql_providers.py +++ b/ct-app/core/components/graphql_providers.py @@ -39,11 +39,9 @@ async def _execute(self, query: DocumentNode, variable_values: dict): query, variable_values=variable_values ) except TransportQueryError as err: - raise ProviderError(err.errors[0]["message"]) + raise ProviderError(f"TransportQueryError error: {err}") except TimeoutError as err: self.error(f"Timeout error: {err}") - except ProviderError as err: - self.error(f"ProviderError error: {err}") except Exception as err: self.error(f"Unknown error: {err}") @@ -120,7 +118,11 @@ async def test(self, **kwargs): ) return False - result = await self._test_query(self._default_key, **kwargs) + try: + result = await self._test_query(self._default_key, **kwargs) + except ProviderError as err: + self.error(f"ProviderError error: {err}") + result = None if result is None: return False From 0a8dc6c3e268c8ded2041165ac5c81e213a39b97 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Thu, 23 May 2024 15:51:42 +0200 Subject: [PATCH 15/27] Update SAFES_BALANCE_URL in secret-subgraph.yaml (#520) --- helm/ctdapp/templates/secret-subgraph.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/helm/ctdapp/templates/secret-subgraph.yaml b/helm/ctdapp/templates/secret-subgraph.yaml index d86c61a8..1053fc53 100644 --- a/helm/ctdapp/templates/secret-subgraph.yaml +++ b/helm/ctdapp/templates/secret-subgraph.yaml @@ -7,7 +7,7 @@ metadata: data: SUBGRAPH_STAKING_URL: {{ .Values.ctdapp.subgraph.stakingUrl | b64enc }} SUBGRAPH_STAKING_URL_BACKUP: {{ .Values.ctdapp.subgraph.stakingUrlBackup | b64enc }} - SUBGRAPH_SAFES_BALANCE_URL: {{ .Values.ctdapp.subgraph.safesBalanceUrl | b64enc }} + SUBGRAPH_SAFES_BALANCE_URL: {{ .Values.ctdapp.subgraph.safesBalanceUrlBackup | b64enc }} SUBGRAPH_SAFES_BALANCE_URL_BACKUP: {{ .Values.ctdapp.subgraph.safesBalanceUrlBackup | b64enc }} SUBGRAPH_WXHOPR_TXS_URL: {{ .Values.ctdapp.subgraph.wxhoprTxsUrl | b64enc }} SUBGRAPH_WXHOPR_TXS_URL_BACKUP: {{ .Values.ctdapp.subgraph.wxhoprTxsUrlBackup | b64enc }} \ No newline at end of file From 87077f34d129fb2a00aa83561d7871b74044e3e7 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Mon, 27 May 2024 15:05:41 +0200 Subject: [PATCH 16/27] Conform to rust api (#457) Co-authored-by: Jean Demeusy Co-authored-by: ausias-armesto Co-authored-by: Tibor <9529609+Teebor-Choka@users.noreply.github.com> --- .gitignore | 3 + ct-app/README.md | 19 +- ct-app/core/__main__.py | 5 +- ct-app/core/components/baseclass.py | 19 ++ ct-app/core/components/graphql_providers.py | 16 +- ct-app/core/components/hoprd_api.py | 161 ++++++---- ct-app/core/components/lockedvar.py | 28 ++ ct-app/core/components/parameters.py | 13 +- ct-app/core/components/utils.py | 61 ++-- ct-app/core/core.py | 71 ++++- ct-app/core/model/address.py | 16 +- ct-app/core/model/economic_model.py | 7 +- ct-app/core/model/peer.py | 16 +- ct-app/core/model/subgraph_entry.py | 20 ++ ct-app/core/model/topology_entry.py | 16 + ct-app/core/node.py | 35 ++- ct-app/database/database_connection.py | 16 +- ct-app/flake.nix | 2 +- ct-app/notebooks/apr_simulation.ipynb | 85 ++---- ct-app/notebooks/relayed_token.ipynb | 284 ------------------ ct-app/postman/postman_tasks.py | 3 + ct-app/requirements.txt | 13 +- ct-app/test/components/test_utils.py | 4 +- .../tests_endurance/module/endurance_test.py | 9 +- ct-app/tests_endurance/test_fund_channels.py | 12 +- ct-app/tests_endurance/test_send_messages.py | 26 +- helm/ctdapp/templates/configmap-nodes.yaml | 9 +- helm/ctdapp/templates/secret-nodes.yaml | 1 - helm/ctdapp/templates/secret-subgraph.yaml | 2 +- helm/ctdapp/values.yaml | 7 +- helm/secrets-prod.sops.yaml | 62 ++-- helm/secrets-staging.sops.yaml | 63 ++-- helm/values-prod-blue.yaml | 2 +- helm/values-prod-green.yaml | 2 +- helm/values-prod.yaml | 13 +- helm/values-staging-blue.yaml | 1 - helm/values-staging.yaml | 15 +- waitlist/__main__.py | 109 ++++--- waitlist/dune_entry.py | 6 +- waitlist/entry.py | 10 +- waitlist/graphql_providers.py | 122 ++++++++ waitlist/registration_entry.py | 50 +-- waitlist/safes_balance.graphql | 15 + waitlist/subgraph_entry.py | 39 +++ 44 files changed, 824 insertions(+), 664 deletions(-) delete mode 100644 ct-app/notebooks/relayed_token.ipynb create mode 100644 waitlist/graphql_providers.py create mode 100644 waitlist/safes_balance.graphql create mode 100644 waitlist/subgraph_entry.py diff --git a/.gitignore b/.gitignore index 96ec9463..0854c8f6 100755 --- a/.gitignore +++ b/.gitignore @@ -3,7 +3,9 @@ __pycache__/ .pytest_cache/ # envs +.venv*/ env*/ + .direnv/ simulation.env .vscode/ @@ -16,6 +18,7 @@ net_viz-*.png out.mp4 websocket_client.log logs/ +*.log #misc .coverage diff --git a/ct-app/README.md b/ct-app/README.md index 0bd6286c..18074c51 100644 --- a/ct-app/README.md +++ b/ct-app/README.md @@ -139,6 +139,7 @@ Parameter | Recommanded value (staging) | Description `GCP_FILE_PREFIX` | `expected_reward` | File prefix for GCP distribution list storage `GCP_FOLDER` | `staging` | Folder on GCP where to store distribution list `PEER_MIN_VERSION` | `2.0.0` | Minimum node version to be eligible + `RABBITMQ_HOST` | (check Bitwarden) | `RABBITMQ_PASSWORD` | (check Bitwarden) | `RABBITMQ_PROJECT_NAME` | `ct-app` | Name of the RabbitMQ project @@ -179,7 +180,6 @@ Flag | Recommanded value (staging) `FLAG_NODE_CLOSE_INCOMING_CHANNELS` (Not available) |-- `FLAG_NODE_GET_TOTAL_CHANNEL_FUNDS` |-- - Those flags turn on the corresponding feature if the variable exist. Also, the value associated to the flag defines the delay between two executions of the methods. #### postman @@ -187,13 +187,19 @@ This module handles message distribution. It relies on a bunch of parameters: Parameter | Recommanded value (staging) | Description --|--|-- -`PARAM_BATCH_SIZE` | `50` | +`PARAM_BATCH_SIZE` | `50` | Number of messages to send before checking the inbox `PARAM_DELAY_BETWEEN_TWO_MESSAGES` | `0.25` | Delay between two messages -`PARAM_MESSAGE_DELIVERY_TIMEOUT` | `10` | Delay between two batches `PARAM_MAX_ATTEMPTS` | `4` | Maximum number of retries before timing out -`RABBITMQ_PROJECT_NAME` | `ct-app` | Name of the RabbitMQ project +`PARAM_MESSAGE_DELIVERY_TIMEOUT` | `10` | Delay between two batches + +#### Common parameters +In addition to the above-mentioned parameters, there's a bunch of parameters that are required to be able to communicate with databases, RabbitMQ brokers, and nodes. +Parameter | Recommanded value (staging) | Description +--|--|-- `RABBITMQ_HOST` | (check Bitwarden) | `RABBITMQ_PASSWORD` | (check Bitwarden) | +`RABBITMQ_PROJECT_NAME` | `ct-app` | Name of the RabbitMQ project +`RABBITMQ_TASK_NAME` | `fake_task` | Task to create when distributing rewards `RABBITMQ_USERNAME` | (check Bitwarden) | `RABBITMQ_VIRTUALHOST` | (check Bitwarden) | `PGHOST` | (from gcloud) | @@ -205,8 +211,9 @@ Parameter | Recommanded value (staging) | Description `PGSSLKEY` |  | Path to the SSL user key `PGSSLROOTCERT` |  | Path to the SSL root certificate `PGSSLMODE` | `verify-ca` | -`NODE_ADDRESS_X` (multiple, min. 2) | (check Bitwarden) | -`NODE_KEY` | (check Bitwarden) | +`NODE_ADDRESS_X` (multiple, min. 2) | (check Bitwarden) | Node endpoints in the format `http://ip:port` +`NODE_KEY_X` (multiple, min. 2) | (check Bitwarden) | Node API token + This program logs to STDOUT. The log level is set to INFO by default. diff --git a/ct-app/core/__main__.py b/ct-app/core/__main__.py index 5dcf7f82..5df17f60 100644 --- a/ct-app/core/__main__.py +++ b/ct-app/core/__main__.py @@ -35,7 +35,10 @@ def main(): instance.post_init(nodes, params) # start the prometheus client - start_http_server(8080) + try: + start_http_server(8080) + except OSError: + instance.error("Address already in use, prometheus client not started") loop = asyncio.new_event_loop() loop.add_signal_handler(SIGINT, instance.stop) diff --git a/ct-app/core/components/baseclass.py b/ct-app/core/components/baseclass.py index c185916a..6a97346e 100644 --- a/ct-app/core/components/baseclass.py +++ b/ct-app/core/components/baseclass.py @@ -6,6 +6,10 @@ class Base: + """ + Base class for logging and printing messages with different colors. + """ + doLogging = True handler = logging.StreamHandler() @@ -31,6 +35,9 @@ def _print(self, message: str, color: str = "\033[0m"): print(self.__format(message, color)) def debug(self, message: str): + """ + Log or print a debug message with the specified message. + """ color = "\033[0;32m" if self.doLogging: self.logger.debug(self.__format(message, color)) @@ -38,6 +45,9 @@ def debug(self, message: str): self._print(message, color) def info(self, message: str): + """ + Log or print an info message with the specified message. + """ color = "\033[0;34m" if self.doLogging: self.logger.info(self.__format(message, color)) @@ -45,6 +55,9 @@ def info(self, message: str): self._print(message, color) def warning(self, message: str): + """ + Log or print a warning message with the specified message. + """ color = "\033[0;33m" if self.doLogging: self.logger.warning(self.__format(message, color)) @@ -52,6 +65,9 @@ def warning(self, message: str): self._print(message, color) def error(self, message: str): + """ + Log or print an error message with the specified message. + """ color = "\033[0;31m" if self.doLogging: self.logger.error(self.__format(message, color)) @@ -59,6 +75,9 @@ def error(self, message: str): self._print(message, color) def feature(self, message: str): + """ + Log or print a feature message with the specified message. + """ color = "\033[0;35m" if self.doLogging: self.logger.info(self.__format(message, color)) diff --git a/ct-app/core/components/graphql_providers.py b/ct-app/core/components/graphql_providers.py index fe42462a..0c99224d 100644 --- a/ct-app/core/components/graphql_providers.py +++ b/ct-app/core/components/graphql_providers.py @@ -1,3 +1,4 @@ +import asyncio from pathlib import Path from gql import Client, gql @@ -54,7 +55,13 @@ async def _test_query(self, key: str, **kwargs) -> bool: """ vars = {"first": 1, "skip": 0} vars.update(kwargs) - response = await self._execute(self._sku_query, vars) + + # call `self._execute(self._sku_query, vars)` with a timeout + try: + response = await asyncio.wait_for(self._execute(self._sku_query, vars), timeout=30) + except asyncio.TimeoutError: + self.error("Query timeout occurred") + return False return response and key in response @@ -73,8 +80,11 @@ async def _get(self, key: str, **kwargs) -> dict: vars = {"first": page_size, "skip": skip} vars.update(kwargs) - response = await self._execute(self._sku_query, vars) - + try: + response = await asyncio.wait_for(self._execute(self._sku_query, vars), timeout=30) + except asyncio.TimeoutError: + self.error("Timeout error while fetching data from subgraph.") + break if response is None: break diff --git a/ct-app/core/components/hoprd_api.py b/ct-app/core/components/hoprd_api.py index bed3f949..17270016 100644 --- a/ct-app/core/components/hoprd_api.py +++ b/ct-app/core/components/hoprd_api.py @@ -1,22 +1,24 @@ import asyncio from typing import Callable, Optional, Union -from hoprd_sdk import ApiClient, Configuration +import requests +from hoprd_sdk import ( + ApiClient, + Configuration, + FundBodyRequest, + OpenChannelBodyRequest, + SendMessageBodyRequest, + TagQueryRequest, +) from hoprd_sdk.api import ( AccountApi, ChannelsApi, MessagesApi, + NetworkApi, NodeApi, - PeersApi, -) -from hoprd_sdk.models import ( - ChannelidFundBody, - ChannelsBody, - MessagesBody, - MessagesPopBody, ) -from hoprd_sdk.models.messages_popall_body import MessagesPopallBody from hoprd_sdk.rest import ApiException +from requests import Response from urllib3.exceptions import MaxRetryError from .baseclass import Base @@ -31,10 +33,10 @@ class HoprdAPI(Base): def __init__(self, url: str, token: str): def _refresh_token_hook(self): - self.api_key["x-auth-token"] = token + self.api_key["X-Auth-Token"] = token self.configuration = Configuration() - self.configuration.host = f"{url}/api/v3" + self.configuration.host = f"{url}" self.configuration.refresh_api_key_hook = _refresh_token_hook @property @@ -115,7 +117,8 @@ async def balances(self, type: Union[str, list[str]] = "all"): elif isinstance(type, str): type = [type] - is_ok, response = await self.__call_api(AccountApi, "account_get_balances") + is_ok, response = await self.__call_api(AccountApi, "balances") + if not is_ok: return None @@ -137,24 +140,26 @@ async def open_channel(self, peer_address: str, amount: str): :param: amount: str :return: channel id: str | undefined """ - body = ChannelsBody(peer_address, amount) + body = OpenChannelBodyRequest(amount, peer_address) is_ok, response = await self.__call_api( ChannelsApi, "channels_open_channel", body=body ) + return response.channel_id if is_ok else None - async def fund_channel(self, channel_id: str, amount: str): + async def fund_channel(self, channel_id: str, amount: float): """ Funds a given channel. :param: channel_id: str - :param: amount: str + :param: amount: float :return: bool """ - body = ChannelidFundBody(amount=f"{amount:.0f}") + body = FundBodyRequest(amount=f"{amount:.0f}") is_ok, _ = await self.__call_api( - ChannelsApi, "channels_fund_channel", channel_id, body=body + ChannelsApi, "fund_channel", channelid=channel_id, body=body ) + return is_ok async def close_channel(self, channel_id: str): @@ -164,7 +169,7 @@ async def close_channel(self, channel_id: str): :return: bool """ is_ok, _ = await self.__call_api( - ChannelsApi, "channels_close_channel", channelid=channel_id + ChannelsApi, "close_channel", channelid=channel_id ) return is_ok @@ -176,9 +181,9 @@ async def incoming_channels(self, only_id: bool = False) -> list: is_ok, response = await self.__call_api( ChannelsApi, - "channels_get_channels", - full_topology="false", - including_closed="false", + "list_channels", + full_topology=False, + including_closed=False, ) if is_ok: if not hasattr(response, "incoming"): @@ -201,7 +206,13 @@ async def outgoing_channels(self, only_id: bool = False): Returns all open outgoing channels. :return: channels: list """ - is_ok, response = await self.__call_api(ChannelsApi, "channels_get_channels") + is_ok, response = await self.__call_api( + ChannelsApi, + "list_channels", + full_topology=False, + including_closed=False, + ) + if is_ok: if not hasattr(response, "outgoing"): self.warning("Response does not contain 'outgoing'") @@ -218,17 +229,6 @@ async def outgoing_channels(self, only_id: bool = False): else: return [] - async def get_channel(self, channel_id: str): - """ - Returns the channel object. - :param: channel_id: str - :return: channel: response - """ - _, response = await self.__call_api( - ChannelsApi, "channels_get_channel", channel_id - ) - return response - async def all_channels(self, include_closed: bool): """ Returns all channels. @@ -237,21 +237,12 @@ async def all_channels(self, include_closed: bool): """ is_ok, response = await self.__call_api( ChannelsApi, - "channels_get_channels", + "list_channels", full_topology="true", - including_closed=include_closed, + including_closed="true" if include_closed else "false", ) return response if is_ok else [] - async def ping(self, peer_id: str): - """ - Pings the given peer_id and returns the measure. - :param: peer_id: str - :return: response: dict - """ - _, response = await self.__call_api(PeersApi, "peers_ping_peer", peerid=peer_id) - return response - async def peers( self, params: Union[list, str] = "peer_id", @@ -265,10 +256,8 @@ async def peers( :param: quality: int = 0..1 :return: peers: list """ + is_ok, response = await self.__call_api(NodeApi, "peers", quality=quality) - is_ok, response = await self.__call_api( - NodeApi, "node_get_peers", quality=quality - ) if not is_ok: return [] @@ -277,7 +266,7 @@ async def peers( return [] if len(getattr(response, status)) == 0: - self.info(f"No peer with is_ok '{status}'") + self.info(f"No peer with state '{status}'") return [] params = [params] if isinstance(params, str) else params @@ -307,7 +296,8 @@ async def get_address( elif isinstance(address, str): address = [address] - is_ok, response = await self.__call_api(AccountApi, "account_get_address") + is_ok, response = await self.__call_api(AccountApi, "addresses") + if not is_ok: return None @@ -332,10 +322,9 @@ async def send_message( :param: tag: int = 0x0320 :return: bool """ - body = MessagesBody(tag, message, destination, path=hops) - is_ok, _ = await self.__call_api( - MessagesApi, "messages_send_message", body=body - ) + body = SendMessageBodyRequest(message, None, hops, destination, tag) + is_ok, _ = await self.__call_api(MessagesApi, "send_message", body=body) + return is_ok async def messages_pop(self, tag: int = MESSAGE_TAG) -> bool: @@ -344,11 +333,9 @@ async def messages_pop(self, tag: int = MESSAGE_TAG) -> bool: :param: tag = 0x0320 :return: dict """ - - body = MessagesPopBody(tag=tag) - _, response = await self.__call_api( - MessagesApi, "messages_pop_message", body=body - ) + body = TagQueryRequest(tag=tag) + _, response = await self.__call_api(MessagesApi, "pop", body=body) + return response async def messages_pop_all(self, tag: int = MESSAGE_TAG) -> list: @@ -357,17 +344,20 @@ async def messages_pop_all(self, tag: int = MESSAGE_TAG) -> list: :param: tag = 0x0320 :return: list """ - - body = MessagesPopallBody(tag=tag) - _, response = await self.__call_api( - MessagesApi, "messages_pop_all_message", body=body - ) + body = TagQueryRequest(tag=tag) + _, response = await self.__call_api(MessagesApi, "pop_all", body=body) return response.messages if hasattr(response, "messages") else [] async def node_info(self): - _, response = await self.__call_api(NodeApi, "node_get_info") + _, response = await self.__call_api(NodeApi, "info") + return response + async def ticket_price(self) -> int: + _, response = await self.__call_api(NetworkApi, "price") + + return float(response.price) / 1e18 if hasattr(response, "price") else None + async def channel_balance(self, src_peer_id: str, dest_peer_id: str) -> float: """ Get the channel balance of a given address. @@ -387,3 +377,46 @@ async def channel_balance(self, src_peer_id: str, dest_peer_id: str) -> float: ] return 0 if len(channel) == 0 else int(channel[0].balance) / 1e18 + + async def startedz(self, timeout: int = 20): + """ + Checks if the node is started. Return True if `startedz` returns 200 after max `timeout` seconds. + """ + return await is_url_returning_200( + f"{self.configuration.host}/startedz", timeout + ) + + async def readyz(self, timeout: int = 20): + """ + Checks if the node is ready. Return True if `readyz` returns 200 after max `timeout` seconds. + """ + return await is_url_returning_200(f"{self.configuration.host}/readyz", timeout) + + async def healthyz(self, timeout: int = 20): + """ + Checks if the node is healthy. Return True if `healthyz` returns 200 after max `timeout` seconds. + """ + return await is_url_returning_200( + f"{self.configuration.host}/healthyz", timeout + ) + + +async def is_url_returning_200(url: str, timeout: int = 20) -> Response: + """ + Checks if the given URL is returning 200 after max `timeout` seconds. + """ + + async def _check_url(url: str): + while True: + try: + req = requests.get(url) + return req + except Exception: + await asyncio.sleep(0.25) + + try: + result = await asyncio.wait_for(_check_url(url), timeout=timeout) + except TimeoutError: + return False + else: + return result.status_code == 200 diff --git a/ct-app/core/components/lockedvar.py b/ct-app/core/components/lockedvar.py index a08a0f8c..b99a7d91 100644 --- a/ct-app/core/components/lockedvar.py +++ b/ct-app/core/components/lockedvar.py @@ -5,19 +5,38 @@ class LockedVar(Base): + """ + A class that represents a locked variable that can be accessed and modified. Any operation on the variable is asynchroneous and locked. The type of the variable can be inferred or set manually. + """ + def __init__(self, name: str, value: Any, infer_type: bool = True): + """ + Create a new LockedVar with the specified name and value. If infer_type is True, the type of the value will be inferred and stored, otherwise it will be None. + + :param name: The name of the variable, for logging purposes. + :param value: The initial value of the variable. The type of the value will be inferred if infer_type is True. + :param infer_type: Whether to infer the type of the initial value or not. + """ self.name = name self.value = value self.lock = asyncio.Lock() self.type = type(value) if infer_type else None async def get(self) -> Any: + """ + Asynchronously get the value of the variable in a locked manner. + """ async with self.lock: if self.type: return self.type(self.value) return self.value async def set(self, value: Any): + """ + Asynchronously set the value of the variable in a locked manner. If the type of the value is different from the type of the variable, a TypeError will be raised. + + :param value: The new value of the variable. + """ if self.type and not isinstance(value, self.type): raise TypeError( f"Trying to set value of type {type(value)} to {self.type}, ignoring" @@ -27,6 +46,11 @@ async def set(self, value: Any): self.value = value async def inc(self, value: Any): + """ + Asyncronously increment the value of the variable by the specified value in a locked manner. If the type of the value is different from the type of the variable, a TypeError will be raised. + + :param value: The value to increment the variable by. + """ if self.type and not isinstance(value, self.type): self.warning( f"Trying to change value of type {type(value)} to {self.type}, ignoring" @@ -36,6 +60,10 @@ async def inc(self, value: Any): self.value += value async def update(self, value: Any): + """ + Asynchronously update the value of the variable with the specified value in a locked manner. If the type of the value is different from the type of the variable, a TypeError will be raised. + This method is meant to be used with dictionaries. + """ if self.type and not isinstance(value, self.type): self.warning( f"Trying to change value of type {type(value)} to {self.type}, ignoring" diff --git a/ct-app/core/components/parameters.py b/ct-app/core/components/parameters.py index 638ce52d..205d1a55 100644 --- a/ct-app/core/components/parameters.py +++ b/ct-app/core/components/parameters.py @@ -3,12 +3,19 @@ class Parameters(Base): - table = [] + """ + Class that represents a set of parameters that can be accessed and modified. The parameters are stored in a dictionary and can be accessed and modified using the dot notation. The parameters can be loaded from environment variables with a specified prefix. + """ def __init__(self): super().__init__() def __call__(self, *prefixes: str or list[str]): + """ + Load the parameters from the environment variables with the specified prefixes. The parameters will be stored in the instance with the name of the prefix in lowercase. If the prefix ends with an underscore, the underscore will be removed. The parameters will be stored in a new instance of the Parameters class. + + :param prefixes: The prefixes of the environment variables to load the parameters from. + """ for prefix in prefixes: subparams = type(self)() @@ -28,7 +35,6 @@ def __call__(self, *prefixes: str or list[str]): integer = int(value) if integer == value: value = integer - except ValueError: pass @@ -37,6 +43,3 @@ def __call__(self, *prefixes: str or list[str]): setattr(self, subparams_name, subparams) return self - - def __str__(self): - return diff --git a/ct-app/core/components/utils.py b/ct-app/core/components/utils.py index ec02649c..9a72daf4 100644 --- a/ct-app/core/components/utils.py +++ b/ct-app/core/components/utils.py @@ -80,44 +80,31 @@ async def post(session: ClientSession, url: str, data: dict, timeout: int): @classmethod def mergeDataSources( cls, - topology_list: list[TopologyEntry], - peers_list: list[Peer], - subgraph_list: list[SubgraphEntry], + topology: list[TopologyEntry], + peers: list[Peer], + safes: list[SubgraphEntry], ): - """ - Merge metrics and subgraph data with the unique peer IDs, addresses, - balance links. - :param: topology_dict: A dict mapping peer IDs to node addresses. - :param: peers_list: A dict containing metrics with peer ID as the key. - :param: subgraph_dict: A dict containing subgraph data with safe address as key. - :returns: A dict with peer ID as the key and the merged information. - """ merged_result: list[Peer] = [] + addresses = [item.node_address for item in topology] - network_addresses = [p.address for p in peers_list] - peer_versions = {p.address: p.version for p in peers_list} + for address in addresses: + peer = next(filter(lambda p: p.address.address == address, peers), None) + topo = next(filter(lambda t: t.node_address == address, topology), None) + safe = next(filter(lambda s: s.node_address == address, safes), None) - # Merge based on peer ID with the channel topology as the baseline - for topology_entry in topology_list: - peer = topology_entry.to_peer() - - entries = [e for e in subgraph_list if e.has_address(peer.address.address)] - if len(entries) > 0: - subgraph_entry: SubgraphEntry = entries[0] - else: - subgraph_entry = SubgraphEntry(None, None, None, None) + ## TEMP SOLUTION TO ENFORCE DISTRIBUTION TO PEERS NOT LISTED BY THE SUBGRAPH ON STAGING + # if safe is None: + # safe = SubgraphEntry(address, "0.000015", "0x0", "10000") - peer.safe_address = subgraph_entry.safe_address - peer.safe_balance = subgraph_entry.wxHoprBalance + if peer is None or topo is None or safe is None: + continue - if subgraph_entry.safe_allowance is not None: - peer.safe_allowance = float(subgraph_entry.safe_allowance) - else: - peer.safe_allowance = None + peer.safe_address = safe.safe_address + peer.safe_balance = safe.wxHoprBalance + peer.safe_allowance = float(safe.safe_allowance) + peer.channel_balance = topo.channels_balance - if peer.complete and peer.address in network_addresses: - peer.version = peer_versions[peer.address] - merged_result.append(peer) + merged_result.append(peer) return merged_result @@ -140,9 +127,7 @@ def allowManyNodePerSafe(cls, peers: list[Peer]): peer.safe_address_count = safe_counts[peer.safe_address] @classmethod - def excludeElements( - cls, source_data: list[Peer], blacklist: list[Address] - ) -> list[Peer]: + def exclude(cls, source_data: list[Peer], blacklist: list[Address]) -> list[Peer]: """ Removes elements from a dictionary based on a blacklist. :param: source_data (dict): The dictionary to be updated. @@ -150,12 +135,8 @@ def excludeElements( :returns: nothing. """ - peer_addresses = [peer.address for peer in source_data] - indexes = [ - peer_addresses.index(address) - for address in blacklist - if address in peer_addresses - ] + addresses = [peer.address for peer in source_data] + indexes = [addresses.index(item) for item in blacklist if item in addresses] # Remove elements from the list excluded = [] diff --git a/ct-app/core/core.py b/ct-app/core/core.py index d3595ea5..45e9b412 100644 --- a/ct-app/core/core.py +++ b/ct-app/core/core.py @@ -45,6 +45,10 @@ class Core(Base): + """ + The Core class represents the main class of the application. It is responsible for managing the nodes, the economic model and the distribution of rewards. + """ + def __init__(self): super().__init__() @@ -62,6 +66,7 @@ def __init__(self): self.registered_nodes = LockedVar("subgraph_list", list[SubgraphEntry]()) self.nft_holders = LockedVar("nft_holders", list[str]()) self.eligible_list = LockedVar("eligible_list", list[Peer]()) + self.ticket_price = LockedVar("ticket_price", 1.0) # subgraphs self._safe_subgraph_url = None @@ -136,6 +141,9 @@ def subgraph_type(self, value: SubgraphType): self._subgraph_type = value async def _retrieve_address(self): + """ + Retrieves the address from the node. + """ addresses = await self.api.get_address("all") if not addresses: self.warning("No address retrieved from node.") @@ -148,15 +156,21 @@ async def _retrieve_address(self): @flagguard @formalin(None) async def healthcheck(self) -> dict: - await self._retrieve_address() - await self.connected.set(self.address is not None) + """ + Checks the health of the node. Sets the connected status (LockedVar) and the Prometheus metric accordingly. + """ + health = await self.api.healthyz() + await self.connected.set(health) - self.debug(f"Connection state: {await self.connected.get()}") - HEALTH.set(int(await self.connected.get())) + self.debug(f"Connection state: {health}") + HEALTH.set(int(health)) @flagguard @formalin("Checking subgraph URLs") async def check_subgraph_urls(self): + """ + Checks the subgraph URLs and sets the subgraph type in use (default, backup or none) + """ for type in SubgraphType.callables(): self.subgraph_type = type provider = SafesProvider(self.safe_subgraph_url) @@ -173,6 +187,9 @@ async def check_subgraph_urls(self): @flagguard @formalin("Aggregating peers") async def aggregate_peers(self): + """ + Aggregates the peers from all nodes and sets the all_peers LockedVar. + """ results = set[Peer]() for node in self.nodes: @@ -186,6 +203,9 @@ async def aggregate_peers(self): @flagguard @formalin("Getting registered nodes") async def get_registered_nodes(self): + """ + Gets the subgraph data and sets the subgraph_list LockedVar. + """ if self.subgraph_type == SubgraphType.NONE: self.warning("No subgraph URL available.") return @@ -255,6 +275,9 @@ async def get_topology_data(self): @flagguard @formalin("Applying economic model") async def apply_economic_model(self): + """ + Applies the economic model to the eligible peers (after multiple filtering layers) and sets the eligible_list LockedVar. + """ ready: bool = False while not ready: @@ -281,7 +304,7 @@ async def apply_economic_model(self): for peer in eligibles if peer.version_is_old(self.params.peer.min_version) ] - excluded = Utils.excludeElements(eligibles, old_peer_addresses) + excluded = Utils.exclude(eligibles, old_peer_addresses) self.debug( f"Excluded peers running on old version (< {self.params.peer.min_version}) ({len(excluded)} entries)." ) @@ -295,13 +318,13 @@ async def apply_economic_model(self): for peer in eligibles if peer.safe_allowance < self.params.economic_model.min_safe_allowance ] - excluded = Utils.excludeElements(eligibles, low_allowance_addresses) + excluded = Utils.exclude(eligibles, low_allowance_addresses) self.debug(f"Excluded nodes with low safe allowance ({len(excluded)} entries).") self.debug(f"peers with low allowance {[el.address.id for el in excluded]}") - excluded = Utils.excludeElements(eligibles, await self.network_nodes_addresses) + excluded = Utils.exclude(eligibles, await self.network_nodes_addresses) self.debug(f"Excluded network nodes ({len(excluded)} entries).") - + if threshold := self.params.economic_model.nft_threshold: low_stake_non_nft_holders = [ peer.address @@ -309,7 +332,7 @@ async def apply_economic_model(self): if peer.safe_address not in nft_holders and peer.split_stake < threshold ] - excluded = Utils.excludeElements(eligibles, low_stake_non_nft_holders) + excluded = Utils.exclude(eligibles, low_stake_non_nft_holders) self.debug( f"Excluded non-nft-holders with stake < {threshold} ({len(excluded)} entries)." ) @@ -317,6 +340,8 @@ async def apply_economic_model(self): model = EconomicModel.fromGCPFile( self.params.gcp.bucket, self.params.economic_model.filename ) + model.budget.ticket_price = await self.ticket_price.get() + for peer in eligibles: peer.economic_model = model peer.max_apr = self.params.distribution.max_apr_percentage @@ -325,10 +350,8 @@ async def apply_economic_model(self): excluded = Utils.rewardProbability(eligibles) self.debug(f"Excluded nodes with low stakes ({len(excluded)} entries).") - self.info(f"Eligible nodes ({len(eligibles)} entries).") - - self.debug(f"final eligible list {[el.address.id for el in eligibles]}") + self.debug(f"Final eligible list {[el.address.id for el in eligibles]}") await self.eligible_list.set(eligibles) @@ -349,10 +372,16 @@ async def apply_economic_model(self): @flagguard @formalin("Distributing rewards") + @connectguard async def distribute_rewards(self): + """ + Distributes the rewards to the eligible peers, based on the economic model. + """ + model = EconomicModel.fromGCPFile( self.params.gcp.bucket, self.params.economic_model.filename ) + model.budget.ticket_price = await self.ticket_price.get() delay = Utils.nextDelayInSeconds(model.delay_between_distributions) self.debug(f"Waiting {delay} seconds for next distribution.") @@ -400,8 +429,11 @@ async def distribute_rewards(self): @formalin("Getting funding data") @connectguard async def get_fundings(self): + """ + Gets the amount of funds all managed nodes have received from a specified address. + """ ct_safe_addresses = { - getattr(await node.api.node_info(), "node_safe", None) + getattr(await node.api.node_info(), "hopr_node_safe", None) for node in self.network_nodes } @@ -420,6 +452,18 @@ async def get_fundings(self): self.debug(f"Total funding: {total_funding}") TOTAL_FUNDING.set(total_funding) + @flagguard + @formalin("Getting ticket price") + @connectguard + async def get_ticket_price(self): + """ + Gets the ticket price from the api and sets the ticket_price LockedVar. The ticket price is used in the economic model to calculate the number of messages to send to a peer. + """ + price = await self.api.ticket_price() + + await self.ticket_price.set(price) + self.debug(f"Ticket price: {price}") + async def start(self): """ Start the node. @@ -443,6 +487,7 @@ async def start(self): self.tasks.add(asyncio.create_task(self.healthcheck())) self.tasks.add(asyncio.create_task(self.check_subgraph_urls())) self.tasks.add(asyncio.create_task(self.get_fundings())) + self.tasks.add(asyncio.create_task(self.get_ticket_price())) self.tasks.add(asyncio.create_task(self.get_nft_holders())) self.tasks.add(asyncio.create_task(self.aggregate_peers())) diff --git a/ct-app/core/model/address.py b/ct-app/core/model/address.py index 1c5e6ddf..250fe31f 100644 --- a/ct-app/core/model/address.py +++ b/ct-app/core/model/address.py @@ -1,15 +1,17 @@ class Address: + """ + Class that represents an address with an id and an address. + """ + def __init__(self, id: str, address: str): + """ + Create a new Address with the specified id and address. The `id` refers the the peerId, and the `address` refers to the native address of a node. + :param id: The id of the peer. + :param address: The address of the peer. + """ self.id = id self.address = address - @property - def short_id(self): - if len(self.id) <= 10: - return self.id - - return self.id[-5:] - def __eq__(self, other): return self.id == other.id and self.address == other.address diff --git a/ct-app/core/model/economic_model.py b/ct-app/core/model/economic_model.py index 8e1437e4..904c99c5 100644 --- a/ct-app/core/model/economic_model.py +++ b/ct-app/core/model/economic_model.py @@ -61,14 +61,12 @@ def __init__( period: float, s: float, distribution_frequency: float, - ticket_price: float, winning_probability: float, ): self.budget = budget self.period = period self.s = s self.distribution_frequency = distribution_frequency - self.ticket_price = ticket_price self.winning_probability = winning_probability @property @@ -122,12 +120,9 @@ def from_dictionary(cls, _input: dict): period = _input.get("budget_period", {}).get("value", None) s = _input.get("s", {}).get("value", None) distribution_frequency = _input.get("dist_freq", {}).get("value", None) - ticket_price = _input.get("ticket_price", {}).get("value", None) winning_probability = _input.get("winning_prob", {}).get("value", None) - return cls( - budget, period, s, distribution_frequency, ticket_price, winning_probability - ) + return cls(budget, period, s, distribution_frequency, winning_probability) @property def delay_between_distributions(self): diff --git a/ct-app/core/model/peer.py b/ct-app/core/model/peer.py index ab4d45d0..9714e259 100644 --- a/ct-app/core/model/peer.py +++ b/ct-app/core/model/peer.py @@ -4,7 +4,17 @@ class Peer: + """ + Representation of a peer in the network. A peer is a node that is part of the network and not hosted by HOPR. + """ + def __init__(self, id: str, address: str, version: str): + """ + Create a new Peer with the specified id, address and version. The id refers to the peerId, the address refers to the native address of a node. + :param id: The peer's peerId + :param address: The peer's native address + :param version: The reported peer's version + """ self.address = Address(id, address) self.version = version self.channel_balance = None @@ -21,6 +31,10 @@ def __init__(self, id: str, address: str, version: str): self.max_apr = float("inf") def version_is_old(self, min_version: str or Version) -> bool: + """ + Check if the peer's version is older than the specified version. + :param min_version: The minimum version to check against. + """ if isinstance(min_version, str): min_version = Version(min_version) @@ -139,7 +153,7 @@ def message_count_for_reward(self): budget = self.economic_model.budget denominator = budget.ticket_price * budget.winning_probability - return round(self.protocol_reward_per_distribution / denominator) + return round(self.protocol_reward_per_distribution / denominator) @property def apr_percentage(self): diff --git a/ct-app/core/model/subgraph_entry.py b/ct-app/core/model/subgraph_entry.py index 2dc89fa1..535cc9e6 100644 --- a/ct-app/core/model/subgraph_entry.py +++ b/ct-app/core/model/subgraph_entry.py @@ -1,4 +1,8 @@ class SubgraphEntry: + """ + A SubgraphEntry represents a single entry in the subgraph. + """ + def __init__( self, node_address: str, @@ -6,6 +10,14 @@ def __init__( safe_address: str, safe_allowance: str, ): + """ + Create a new SubgraphEntry with the specified node_address, wxHoprBalance, safe_address and safe_allowance. + :param node_address: The address of the node. + :param wxHoprBalance: The wxHoprBalance of the node. + :param safe_address: The address of the safe. + :param safe_allowance: The wxHoprAllowance of the safe. + """ + self.node_address = node_address self.wxHoprBalance = wxHoprBalance self.safe_address = safe_address @@ -13,6 +25,10 @@ def __init__( @classmethod def fromSubgraphResult(cls, node: dict): + """ + Create a new SubgraphEntry from the specified subgraph result. + :param node: The subgraph result to create the SubgraphEntry from. + """ return cls( node["node"]["id"], node["safe"]["balance"]["wxHoprBalance"], @@ -21,6 +37,10 @@ def fromSubgraphResult(cls, node: dict): ) def has_address(self, address: str): + """ + Check if the SubgraphEntry has the specified address. + :param address: The address to check for. + """ return self.node_address == address def __eq__(self, other): diff --git a/ct-app/core/model/topology_entry.py b/ct-app/core/model/topology_entry.py index c77ca203..72eb7be7 100644 --- a/ct-app/core/model/topology_entry.py +++ b/ct-app/core/model/topology_entry.py @@ -2,13 +2,29 @@ class TopologyEntry: + """ + Class that represents a single topology entry (from the API). + """ + def __init__(self, peer_id: str, node_address: str, channels_balance: int): + """ + Create a new TopologyEntry with the specified peer_id, node_address and channels_balance. + :param peer_id: The peer's peerId. + :param node_address: The peer's native address. + :param channels_balance: The peer's outgoing channels total balance. + """ self.peer_id: str = peer_id self.node_address = node_address self.channels_balance = channels_balance @classmethod def fromDict(cls, peer_id: str, value: dict): + """ + Create a new TopologyEntry from the specified dictionary. + :param peer_id: The peer's peerId. + :param value: The dictionary to create the TopologyEntry from. + """ + return cls(peer_id, value["source_node_address"], value["channels_balance"]) def __repr__(self): diff --git a/ct-app/core/node.py b/ct-app/core/node.py index fb162ce5..419ed41c 100644 --- a/ct-app/core/node.py +++ b/ct-app/core/node.py @@ -57,7 +57,16 @@ class Node(Base): + """ + A Node represents a single node in the network, managed by HOPR, and used to distribute rewards. + """ + def __init__(self, url: str, key: str): + """ + Create a new Node with the specified url and key. + :param url: The url of the node. + :param key: The key of the node. + """ super().__init__() self.api: HoprdAPI = HoprdAPI(url, key) @@ -79,7 +88,10 @@ def __init__(self, url: str, key: str): def print_prefix(self): return ".".join(self.url.split("//")[-1].split(".")[:2]) - async def _retrieve_address(self) -> Address: + async def _retrieve_address(self): + """ + Retrieve the address of the node. + """ address = await self.api.get_address("all") if not isinstance(address, dict): @@ -95,12 +107,16 @@ async def _retrieve_address(self) -> Address: @flagguard @formalin(None) async def healthcheck(self): - node_address = await self._retrieve_address() - await self.connected.set(node_address is not None) + """ + Perform a healthcheck on the node. + """ + health = await self.api.healthyz() + await self.connected.set(health) + self.debug(f"Connection state: {health}") - if addr := node_address: - self.debug(f"Connection state: {await self.connected.get()}") - HEALTH.labels(addr.id).set(int(await self.connected.get())) + if addr := await self._retrieve_address(): + self.debug(f"Connection state: {health}") + HEALTH.labels(addr.id).set(int(health)) else: self.warning("No address found") @@ -108,6 +124,9 @@ async def healthcheck(self): @formalin("Retrieving balances") @connectguard async def retrieve_balances(self): + """ + Retrieve the balances of the node. + """ balances = await self.api.balances() node_address = await self.address.get() @@ -190,8 +209,8 @@ async def close_pending_channels(self): """ Close channels in PendingToClose state. """ - node_address = await self.address.get() + node_address = await self.address.get() out_pendings = [ c for c in await self.outgoings.get() if ChannelStatus.isPending(c.status) ] @@ -394,6 +413,8 @@ async def get_total_channel_funds(self): results = await Utils.aggregatePeerBalanceInChannels(channels) + self.debug(f"Results of channels balance aggregation: {results}") + if node_address.id not in results: self.warning("Funding info not found") return diff --git a/ct-app/database/database_connection.py b/ct-app/database/database_connection.py index 511fd8bf..4047c2dc 100644 --- a/ct-app/database/database_connection.py +++ b/ct-app/database/database_connection.py @@ -16,8 +16,10 @@ class DatabaseConnection: """ def __init__(self): + """ + Create a new DatabaseConnection based on environment variables setting user, password, host, port, database, sslmode, sslrootcert, sslcert and sslkey. + """ self.params = Parameters()("PG") - self._assert_parameters() url = URL( @@ -37,6 +39,9 @@ def __init__(self): log.info("Database connection established.") def _assert_parameters(self): + """ + Asserts that all required parameters are set. + """ for group, values in self.required_parameters().items(): assert len(getattr(self.params, group).__dict__), ( f"Missing all '{group.upper()}' environment variables. " @@ -52,6 +57,9 @@ def _assert_parameters(self): @classmethod def required_parameters(cls): + """ + Returns the required parameters for the DatabaseConnection. + """ return { "pg": [ "user", @@ -63,9 +71,15 @@ def required_parameters(cls): } def __enter__(self): + """ + Return the session (used by context manager) + """ return self.session def __exit__(self, exc_type, exc_value, traceback): + """ + Close the session and the engine (used by context manager) + """ self.session.close() self.engine.dispose() log.info("Database connection closed.") diff --git a/ct-app/flake.nix b/ct-app/flake.nix index 431efbf3..84ed2e3c 100644 --- a/ct-app/flake.nix +++ b/ct-app/flake.nix @@ -17,7 +17,7 @@ python39Packages.venvShellHook ]; - venvDir = "./env"; + venvDir = "./.venv"; postVenvCreation = '' unset SOURCE_DATE_EPOCH pip install -U pip setuptools wheel diff --git a/ct-app/notebooks/apr_simulation.ipynb b/ct-app/notebooks/apr_simulation.ipynb index 52efbad0..c6a84a66 100644 --- a/ct-app/notebooks/apr_simulation.ipynb +++ b/ct-app/notebooks/apr_simulation.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -109,19 +109,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Topology size: 387\n", - "Subgraph size: 543\n", - "Number of peers: 357\n" - ] - } - ], + "outputs": [], "source": [ "topology = await get_topology_data()\n", "print(f\"Topology size: {len(topology)}\")\n", @@ -135,21 +125,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Eligible peers: 275\n" - ] - } - ], + "outputs": [], "source": [ - "eligible = Utils.mergeTopologyPeersSubgraph(topology, peers, subgraph)\n", + "eligible = Utils.mergeTopoPeersSafes(topology, peers, subgraph)\n", "Utils.allowManyNodePerSafe(eligible)\n", - "Utils.excludeElements(eligible, [node.address for node in network_nodes])\n", + "Utils.exclude(eligible, [node.address for node in network_nodes])\n", "model = EconomicModel.fromGCPFile(\n", " params.gcp.bucket, params.economic_model.filename\n", ")\n", @@ -163,7 +145,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -300,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -332,20 +314,9 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "prefered_vars = [deepcopy(prefered) for _ in range(3)]\n", "\n", @@ -361,20 +332,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "min stake: 10000.00 HOPR\n", - "max stake: 351004.55 HOPR\n", - "average stake: 47698.08 HOPR\n", - "median stake: 42039.64 HOPR\n" - ] - } - ], + "outputs": [], "source": [ "print(f\"min stake: {min(data):.2f} HOPR\")\n", "print(f\"max stake: {max(data):.2f} HOPR\")\n", @@ -384,20 +344,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "_, axes = plt.subplots(2, 3, figsize=(14, 8), dpi=300, sharey=True)\n", "axes = axes.flatten()\n", diff --git a/ct-app/notebooks/relayed_token.ipynb b/ct-app/notebooks/relayed_token.ipynb deleted file mode 100644 index 074a8780..00000000 --- a/ct-app/notebooks/relayed_token.ipynb +++ /dev/null @@ -1,284 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Relayed HOPR tokens by the ct-app" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from dotenv import load_dotenv\n", - "import sys\n", - "sys.path.append(\"../\")\n", - "\n", - "from core.components.parameters import Parameters # noqa: E402\n", - "from core.components.utils import Utils # noqa: E402\n", - "from core.model.subgraph_entry import SubgraphEntry # noqa: E402\n", - "from core.model.topology_entry import TopologyEntry # noqa: E402\n", - "from core.model.economic_model import EconomicModel # noqa: E402\n", - "from core.model.peer import Peer # noqa: E402\n", - "from core.node import Node # noqa: E402" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Load environment variables\n", - "load_dotenv(\".envs/relayed_token.env\")\n", - "\n", - "params = Parameters()(\"SUBGRAPH_\", \"GCP_\", \"ECONOMIC_MODEL_\")\n", - "nodes = Node.fromAddressAndKeyLists(*Utils.nodesAddresses(\"NODE_ADDRESS_\", \"NODE_KEY_\"))\n", - "\n", - "api = nodes[-1].api\n", - "network_nodes = nodes[:-1]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "async def get_subgraph_data():\n", - " data = {\n", - " \"query\": params.subgraph.safes_balance_query,\n", - " \"variables\": {\"first\": params.subgraph.pagination_size, \"skip\": 0},\n", - " }\n", - "\n", - " safes = []\n", - " while True:\n", - " _, response = await Utils.httpPOST(\n", - " params.subgraph.safes_balance_url, data\n", - " )\n", - "\n", - " if \"data\" not in response:\n", - " break\n", - "\n", - " safes.extend(response[\"data\"][\"safes\"])\n", - "\n", - " if len(response[\"data\"][\"safes\"]) >= params.subgraph.pagination_size:\n", - " data[\"variables\"][\"skip\"] += params.subgraph.pagination_size\n", - " else:\n", - " break\n", - "\n", - " results = list[SubgraphEntry]()\n", - " for safe in safes:\n", - " results.extend(\n", - " [\n", - " SubgraphEntry.fromSubgraphResult(node)\n", - " for node in safe[\"registeredNodesInNetworkRegistry\"]\n", - " ]\n", - " )\n", - "\n", - "\n", - " return results\n", - "\n", - "async def get_topology_data():\n", - " channels = await api.all_channels(False)\n", - "\n", - " results = await Utils.aggregatePeerBalanceInChannels(channels.all)\n", - " return [TopologyEntry.fromDict(*arg) for arg in results.items()]\n", - "\n", - "async def get_node_data():\n", - " results = set[Peer]()\n", - "\n", - " for node in network_nodes:\n", - " await node._retrieve_address()\n", - " node_result = await node.api.peers(params=[\"peer_id\", \"peer_address\"], quality=0.5)\n", - " \n", - " peers = {Peer(item[\"peer_id\"], item[\"peer_address\"]) for item in node_result}\n", - " results.update(peers)\n", - "\n", - " return results\n", - "\n", - "async def get_fundings(from_address: str, to_address: str):\n", - " query: str = params.subgraph.wxhopr_txs_query\n", - " query = query.replace(\"$from\", f'\\\"{from_address}\\\"')\n", - " query = query.replace(\"$to\", f'\\\"{to_address}\\\"')\n", - "\n", - " _, response = await Utils.httpPOST(params.subgraph.wxhopr_txs_url, { \"query\": query })\n", - "\n", - " amounts = [float(tx[\"amount\"]) for tx in response[\"data\"][\"transactions\"]] \n", - "\n", - " return amounts" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Topology size: 397\n", - "Subgraph size: 552\n", - "Number of peers: 352\n" - ] - } - ], - "source": [ - "topology = await get_topology_data()\n", - "print(f\"Topology size: {len(topology)}\")\n", - "\n", - "subgraph = await get_subgraph_data()\n", - "print(f\"Subgraph size: {len(subgraph)}\")\n", - "\n", - "peers = await get_node_data()\n", - "print(f\"Number of peers: {len(peers)}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Eligible peers: 287\n" - ] - } - ], - "source": [ - "eligible = Utils.mergeTopologyPeersSubgraph(topology, peers, subgraph)\n", - "Utils.allowManyNodePerSafe(eligible)\n", - "model = EconomicModel.fromGCPFile(\n", - " params.gcp.bucket, params.economic_model.filename\n", - ")\n", - "for peer in eligible:\n", - " peer.economic_model = model\n", - " \n", - "Utils.rewardProbability(eligible)\n", - "\n", - "print(f\"Eligible peers: {len(eligible)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Funds of Netwatchers " - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[72600.9, 72699.6, 73160.9, 73813.5]\n" - ] - } - ], - "source": [ - "node_funds = []\n", - "\n", - "for node in network_nodes:\n", - " peer = [peer for peer in eligible if peer.address == node.address][0]\n", - " node_funds.append(peer.total_balance)\n", - "\n", - "print(node_funds)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Relayed Token Calculation " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ct_funding_received=350_000.00\n", - "distributed_rewards=57_725.10\n" - ] - } - ], - "source": [ - "ct_nodes = []\n", - "for node in network_nodes:\n", - " node = [e for e in eligible if e.address == node.address][0]\n", - " ct_nodes.append(node)\n", - "\n", - "ct_funding_received=0\n", - "for node in ct_nodes:\n", - " amounts = await get_fundings(\"0xd9a00176cf49dfb9ca3ef61805a2850f45cb1d05\", node.safe_address)\n", - " ct_funding_received += sum(amounts)\n", - "\n", - "distributed_rewards = ct_funding_received - sum(node_funds)\n", - "print(f\"{ct_funding_received=:_.2f}\")\n", - "print(f\"{distributed_rewards=:_.2f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "total_rewards=207_725.10\n" - ] - } - ], - "source": [ - "airdropped = 6*25_000 # Get this number from Andrius\n", - "total_rewards = airdropped + distributed_rewards\n", - "print(f\"{total_rewards=:_.2f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.18" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/ct-app/postman/postman_tasks.py b/ct-app/postman/postman_tasks.py index 78a05fc7..8c242b54 100644 --- a/ct-app/postman/postman_tasks.py +++ b/ct-app/postman/postman_tasks.py @@ -118,6 +118,9 @@ async def async_send_1_hop_message( # validate balance of peer balance = await api.channel_balance(node_peer_id, peer_id) + print( + f"Should send {expected_count} messages to {peer_id} with balance {balance=} (ticket price: {ticket_price})" + ) max_possible = min(expected_count, balance // ticket_price) if max_possible == 0: diff --git a/ct-app/requirements.txt b/ct-app/requirements.txt index cb9616ea..eed7280a 100644 --- a/ct-app/requirements.txt +++ b/ct-app/requirements.txt @@ -1,4 +1,4 @@ -git+https://github.com/hoprnet/hoprd-sdk-python.git@v2.0.5 +git+https://github.com/hoprnet/hoprd-sdk-python.git@v2.1.0-rc.3 aiohttp==3.8.4 numpy==1.25.0 pytest==7.1.3 @@ -11,7 +11,12 @@ prometheus_client==0.17.1 sqlalchemy==2.0.20 psycopg2==2.9.7 google-cloud-storage==2.10.0 -black>=23.3.0 -pip-chill>=1.0.3 -ruff>=0.0.270 +black==24.3.0 +pip-chill==1.0.3 +ruff==0.3.3 +python-dotenv==1.0.1 +pandas>=2.2.1 +dune-client==1.7.0 +openpyxl==3.1.2 +dataclasses-json==0.6.4 gql==3.5.0 \ No newline at end of file diff --git a/ct-app/test/components/test_utils.py b/ct-app/test/components/test_utils.py index 830f2913..ba8d59f9 100644 --- a/ct-app/test/components/test_utils.py +++ b/ct-app/test/components/test_utils.py @@ -86,7 +86,7 @@ def test_allowManyNodePerSafe(): assert peer_3.safe_address_count == 1 -def test_excludeElements(): +def test_exclude(): source_data = [ Peer("id_1", "address_1", "v1.0.0"), Peer("id_2", "address_2", "v1.1.0"), @@ -96,7 +96,7 @@ def test_excludeElements(): ] blacklist = [Address("id_2", "address_2"), Address("id_4", "address_4")] - excluded = Utils.excludeElements(source_data, blacklist) + excluded = Utils.exclude(source_data, blacklist) assert len(source_data) == 3 assert len(excluded) == 2 diff --git a/ct-app/tests_endurance/module/endurance_test.py b/ct-app/tests_endurance/module/endurance_test.py index ac369101..c2add566 100644 --- a/ct-app/tests_endurance/module/endurance_test.py +++ b/ct-app/tests_endurance/module/endurance_test.py @@ -3,12 +3,13 @@ import pprint import time from datetime import timedelta +from logging import getLogger -from tools.utils import envvar, getlogger +from core.components.utils import Utils from .metric import Metric -log = getlogger() +log = getLogger() class EnduranceTest(object): @@ -27,8 +28,8 @@ def __init__(self, duration: int, rate: float): self.metric_list: list[Metric] = [] self._progress_bar_length = 45 - log.setLevel(getattr(logging, envvar("LOG_LEVEL", default="INFO"))) - log.disabled = not envvar("LOG_ENABLED", type=bool, default=True) + log.setLevel(getattr(logging, Utils.envvar("LOG_LEVEL", default="INFO"))) + log.disabled = not Utils.envvar("LOG_ENABLED", type=bool, default=True) async def progress_bar(self): """ diff --git a/ct-app/tests_endurance/test_fund_channels.py b/ct-app/tests_endurance/test_fund_channels.py index d22b55e1..dbfcc2a5 100644 --- a/ct-app/tests_endurance/test_fund_channels.py +++ b/ct-app/tests_endurance/test_fund_channels.py @@ -1,15 +1,17 @@ import asyncio import random -from tools import HoprdAPIHelper, envvar +from core.components.hoprd_api import HoprdAPI +from core.components.utils import Utils +# tools import HoprdAPIHelper, envvar from . import EnduranceTest, Metric class FundChannels(EnduranceTest): async def on_start(self): self.results = [] - self.api = HoprdAPIHelper(envvar("API_URL"), envvar("API_KEY")) + self.api = HoprdAPI(Utils.envvar("API_URL"), Utils.envvar("API_KEY")) address = await self.api.get_address("hopr") self.info(f"Connected to node '...{address[-10:]}'") @@ -29,7 +31,9 @@ async def on_start(self): self.info(f"balance: {self.inital_balance}", prefix="\t") async def task(self) -> bool: - success = await self.api.fund_channel(self.channel.id, envvar("FUND_AMOUNT")) + success = await self.api.fund_channel( + self.channel.id, Utils.envvar("FUND_AMOUNT") + ) self.results.append(success) async def on_end(self): @@ -44,7 +48,7 @@ async def balance_changed(id: str, balance: str): return channel.balance - timeout = envvar("BALANCE_CHANGE_TIMEOUT", float) + timeout = Utils.envvar("BALANCE_CHANGE_TIMEOUT", float) self.info(f"Waiting up to {timeout}s for the balance to change") try: self.final_balance = await asyncio.wait_for( diff --git a/ct-app/tests_endurance/test_send_messages.py b/ct-app/tests_endurance/test_send_messages.py index 06afa9bb..ae5deb3b 100644 --- a/ct-app/tests_endurance/test_send_messages.py +++ b/ct-app/tests_endurance/test_send_messages.py @@ -1,7 +1,8 @@ import asyncio import random -from tools import HoprdAPIHelper, envvar +from core.components.hoprd_api import HoprdAPI +from core.components.utils import Utils from . import EnduranceTest, Metric @@ -10,7 +11,7 @@ class SendMessages(EnduranceTest): async def on_start(self): self.results = [] - self.api = HoprdAPIHelper(envvar("API_URL"), envvar("API_KEY")) + self.api = HoprdAPI(Utils.envvar("API_URL"), Utils.envvar("API_KEY")) self.recipient = await self.api.get_address("hopr") channels = await self.api.all_channels(False) @@ -23,7 +24,14 @@ async def on_start(self): if len(open_channels) == 0: raise Exception("No open channels found") - channel = random.choice(open_channels) + selected_peer_id = Utils.envvar("RELAYER_PEER_ID") + + if selected_peer_id is not None: + channel = [ + c for c in open_channels if c.destination_peer_id == selected_peer_id + ][0] + else: + channel = random.choice(open_channels) self.relayer = channel.destination_peer_id @@ -33,20 +41,20 @@ async def on_start(self): self.info(f"status : {channel.status}", prefix="\t") self.info(f"balance: {channel.balance}HOPR", prefix="\t") - await self.api.messages_pop_all(envvar("MESSAGE_TAG", int)) + await self.api.messages_pop_all(Utils.envvar("MESSAGE_TAG", type=int)) async def task(self) -> bool: success = await self.api.send_message( self.recipient, "Load testing", [self.relayer], - envvar("MESSAGE_TAG", int), + Utils.envvar("MESSAGE_TAG", type=int), ) self.results.append(success) async def on_end(self): - sleep_time = envvar("DELAY_BEFORE_INBOX_CHECK", float) + sleep_time = Utils.envvar("DELAY_BEFORE_INBOX_CHECK", type=float) if sum(self.results) > 0: self.info(f"Waiting {sleep_time}s for messages to be relayed") @@ -54,12 +62,12 @@ async def on_end(self): else: self.warning("No messages were relayed, skipping wait") - inbox = await self.api.messages_pop_all(envvar("MESSAGE_TAG", int)) + inbox = await self.api.messages_pop_all(Utils.envvar("MESSAGE_TAG", type=int)) self.inbox_size = len(inbox) def success_flag(self) -> bool: return sum(self.results) / len(self.results) >= 0.9 - + def metrics(self): # Messages counts expected_messages = Metric( @@ -117,5 +125,3 @@ def metrics(self): issuing_speed, delivery_speed, ] - - \ No newline at end of file diff --git a/helm/ctdapp/templates/configmap-nodes.yaml b/helm/ctdapp/templates/configmap-nodes.yaml index 44117ade..165ad4ac 100644 --- a/helm/ctdapp/templates/configmap-nodes.yaml +++ b/helm/ctdapp/templates/configmap-nodes.yaml @@ -5,9 +5,6 @@ metadata: argocd.argoproj.io/sync-wave: "1" name: hoprd-nodes data: - NODE_ADDRESS_1: http://hoprd-ctdapp-1:3001 - NODE_ADDRESS_2: http://hoprd-ctdapp-2:3001 - NODE_ADDRESS_3: http://hoprd-ctdapp-3:3001 - NODE_ADDRESS_4: http://hoprd-ctdapp-4:3001 - NODE_ADDRESS_5: http://hoprd-ctdapp-5:3001 - NODE_ADDRESS_X: http://hoprd-ctdapp-5:3001 +{{- range $key, $value := .Values.ctdapp.nodes }} + {{ $key }}: {{ $value }} +{{- end }} \ No newline at end of file diff --git a/helm/ctdapp/templates/secret-nodes.yaml b/helm/ctdapp/templates/secret-nodes.yaml index 272e040b..bf0f7d2e 100644 --- a/helm/ctdapp/templates/secret-nodes.yaml +++ b/helm/ctdapp/templates/secret-nodes.yaml @@ -12,4 +12,3 @@ data: NODE_KEY_5: {{ .Values.wallet.hoprdApiToken | b64enc }} NODE_KEY_X: {{ .Values.wallet.hoprdApiToken | b64enc }} - diff --git a/helm/ctdapp/templates/secret-subgraph.yaml b/helm/ctdapp/templates/secret-subgraph.yaml index 1053fc53..506ebc5c 100644 --- a/helm/ctdapp/templates/secret-subgraph.yaml +++ b/helm/ctdapp/templates/secret-subgraph.yaml @@ -10,4 +10,4 @@ data: SUBGRAPH_SAFES_BALANCE_URL: {{ .Values.ctdapp.subgraph.safesBalanceUrlBackup | b64enc }} SUBGRAPH_SAFES_BALANCE_URL_BACKUP: {{ .Values.ctdapp.subgraph.safesBalanceUrlBackup | b64enc }} SUBGRAPH_WXHOPR_TXS_URL: {{ .Values.ctdapp.subgraph.wxhoprTxsUrl | b64enc }} - SUBGRAPH_WXHOPR_TXS_URL_BACKUP: {{ .Values.ctdapp.subgraph.wxhoprTxsUrlBackup | b64enc }} \ No newline at end of file + SUBGRAPH_WXHOPR_TXS_URL_BACKUP: {{ .Values.ctdapp.subgraph.wxhoprTxsUrlBackup | b64enc }} diff --git a/helm/ctdapp/values.yaml b/helm/ctdapp/values.yaml index 6c8ef31c..7f617495 100644 --- a/helm/ctdapp/values.yaml +++ b/helm/ctdapp/values.yaml @@ -25,7 +25,12 @@ ctdapp: type: ClusterIP port: 8080 - + nodes: {} + # NODE_ADDRESS_1: http://hoprd-ctdapp-1:3001 + # NODE_ADDRESS_2: http://hoprd-ctdapp-2:3001 + # NODE_ADDRESS_3: http://hoprd-ctdapp-3:3001 + # NODE_ADDRESS_4: http://hoprd-ctdapp-4:3001 + # NODE_ADDRESS_5: http://hoprd-ctdapp-5:3001 core: repository: europe-west3-docker.pkg.dev/hoprassociation/docker-images/cover-traffic diff --git a/helm/secrets-prod.sops.yaml b/helm/secrets-prod.sops.yaml index d7706997..977c8c84 100644 --- a/helm/secrets-prod.sops.yaml +++ b/helm/secrets-prod.sops.yaml @@ -1,45 +1,53 @@ wallet: - deployerPrivateKey: ENC[AES256_GCM,data:RElyy52nA0/VE2QISVliJkWXeAVjTHpi/UPKDx/xpvbeYkPlRf1MMQWzRfI4y/+cdHGJc8EXuyfMzZLM0vlbdA==,iv:ZKQWRnYijrmO0gK368+4v+3SwlIBHw5LRFGmXCy25IQ=,tag:qlG3R2tjrtKIFulsfUU9XQ==,type:str] - identityPassword: ENC[AES256_GCM,data:FzOLX0kYIJPxpq3kg8T9EzqlfO5Worc=,iv:kw3ugpdN+6BkjmwmveMX+C34GbrcloV1AESw/tj9RsM=,tag:jk8lyAHx1pR8pVMqN+OlGA==,type:str] - hoprdApiToken: ENC[AES256_GCM,data:/CafRsA8+tevF0GuHjK1G7mrACr2zImhiEKgJOA6jhTX22qX83LMtX2nmmJKXBedvvU/3g==,iv:M7a7bX4O6VSjhq5xXNo9YYM7FSg2vwtVXeYVp9vCRTk=,tag:0eCDQXwKuqeRq627ia5TJw==,type:str] + deployerPrivateKey: ENC[AES256_GCM,data:g2QiE676T0TfGm6lnH/f+M1jHkMbAA8c2zQioUTHaY0dMxprdUwxUGNFmXGgZV/qk7S1iT72hKXQW7wtgDRakQ==,iv:Sur8/cctcmA//+e1YXQZbOeA6FrwI1arpKj4P7gKyRk=,tag:oCyOL0AE0hi95cjgx1iubQ==,type:str] + identityPassword: ENC[AES256_GCM,data:CjRp0Hx1CYsI3HadQEepjsZPzwzrIX4=,iv:aGsBxf2zNsIs6zyG7le+RTcuSwDlO77JFhmQsmsgpuE=,tag:AmEPhJOPGCeereT/F0femw==,type:str] + hoprdApiToken: ENC[AES256_GCM,data:CCl9hDYVR85GRuiDKjic8oR/CvU9WiL2e+lwr/zdob6jKdbR43lmMkjxDEXuBFzQEjU4EQ==,iv:pflX4t7LapcgWlFeHjTYRnJ7Uv1UdFyf0+op180cvs0=,tag:QCw8UKthHISJap0/Q3n1YQ==,type:str] ctdapp: postgres: - database: ENC[AES256_GCM,data:88fjXpTB,iv:4tph75aNdNuAYmdhUW63HHDQJCeDUXRE/3+Gbc7jN18=,tag:crCiy+hXtVSFqF5ivvoBtA==,type:str] - host: ENC[AES256_GCM,data:SXC+V+6VfE25ZZvrolNjOYyJFVWLwVnN,iv:VXHn7SinTv1emTKrI9X/ioE4x38Val99ZhnnfrSqHM8=,tag:gVNF/mU0IxmqFBuGM62MjQ==,type:str] - password: ENC[AES256_GCM,data:9bSGfdYhAJ56YLzr5p0F3On2ClaYSxfgvPQmXoqYaREIJxoHzQnsnxavNsTbEyMimotwlZET10U6WGvbA2gW9A==,iv:R4ZzZ9IWIfBM6fI4h3kq7FwSUiWyiT2vOPZNRmV2xzA=,tag:yNsLNccffSXwiCuumF8KbQ==,type:str] - port: ENC[AES256_GCM,data:vuFTbQ==,iv:9yDTSwKXdWvt1lkVvl+QoC1wnE+qD653wYFMTuppYyM=,tag:Mdbzs4jCvKNtD3GUBuq6xg==,type:str] - username: ENC[AES256_GCM,data:KkDjvb1N,iv:5Vv30U3IrFAAV5TbI9j5Tgbg+aS+Fz/q7phHs5gfFMg=,tag:iEKuvWTFr2yC3P+2+ugWuw==,type:str] + database: ENC[AES256_GCM,data:s3jMTK8j,iv:HiMvJZvRidYtKaYZEK2nxNl10ezmxLytIhIzujyccs4=,tag:v0PSK4tpbIyOD1jDqBDbQA==,type:str] + host: ENC[AES256_GCM,data:yFuQJAR9znFQBnR92aOKWROh55gL38m+,iv:6bFpkRC+wmMveQ0XePG+rWp/O/Kw9y1BnFZyDd6W7ko=,tag:UnA/iTx8SKi70DjTggHCSA==,type:str] + password: ENC[AES256_GCM,data:3BUDmOw/D3jVCQVl9Pd8C6zE39tPI3UOyU2g8GAWukjw0PsGwY2IZaS40tkCOfDM+qmImzA/qe9TG50pDQYCwQ==,iv:E6T4tQhbc5LUEqEs6hNT/PQb27uVvAKLPivCj3H0KMM=,tag:VqMcJWPJX1WWWdzxhN9TbQ==,type:str] + port: ENC[AES256_GCM,data:sD2jIA==,iv:54R+T/5sjhX2SVMMVg6nh+SFtka9TEdkY9LiGFqRtyQ=,tag:Q7M6oh6/hfYRMqsLKr0LQA==,type:str] + username: ENC[AES256_GCM,data:jX5kdbfp,iv:IIlYrXPRVBCOSeQliizG/Iv5j5ufCTxsq6e0uiNsyT0=,tag:GZ3wFuuGY+YkJaSOBe9c/g==,type:str] rabbitmq: - celeryBrokerUrl: ENC[AES256_GCM,data:YeJ3+fQakxITppmjR9WfvArngsiOqIxVnD3XKP4+u4M+O8f8DX51DaEakjaMs9z8gmIgEKMwPLTG6w7DJrmUve5SESrTwuq8UBJjgRUuQI9pJTYY53ptNqpxOT7bkstxBZQAubTWlqVVYKtQbFw9EwbbvyE2d5JYoxcxf+MmEnV3W399R2mBlXMbInWtPCjv54+6ZOcbZ3UW,iv:C3ikenpLqSOC3HeI2pgPuOWwX9uhBg62Axwcgz1naic=,tag:rIzMYCRzEjd8kOJrKakuiA==,type:str] - host: ENC[AES256_GCM,data:wolMpSLTdXiUoav37BJYi1Ze8R2z0Dg+L93nvjuUuVk=,iv:Yu0zzEK/rbftQB9SqDBzUlE6B66kSN6o2GUUFv3MzP4=,tag:5+3J7vd0okvJ2ISr26NWZg==,type:str] - password: ENC[AES256_GCM,data:z1UL135iNu92XqTi7LOSIggBRbPoiDs+M+C9ss8yCVb3pQm3cnJRQHriUVVQNR37AuKMT/jYTdB0VfpC0DXGIw==,iv:0uSO9/ZCyu0sfI9ySg5RR4ftkVGU9wuhWICxHYtg4fk=,tag:cOByGF+CTJzP7njuM+jAhQ==,type:str] - username: ENC[AES256_GCM,data:UqEYdiPk,iv:hQfljaXwcq7SVp48YmobIszg3tz7OKLTuSbRwncY8lI=,tag:/jbvYrZHMqhH9H2SsrkZSw==,type:str] - virtualhost: ENC[AES256_GCM,data:gPQRRa/R,iv:Xc4CckYql/LCTZ8hODS20BpFwk6nC7Wva3jAhW3DiRs=,tag:iQK6s27EKxmBz1gyKr5sWA==,type:str] + celeryBrokerUrl: ENC[AES256_GCM,data:HLZ+WWlt/1nZpB8aI2igxXOgdWNgQp2R2xW51VcgLEyQmeDW9RW9Pb5FfS5jE2gSHjIMqmItqbwpMmkRzfEJjbFp5Lbg0iVfruBzdlwdrfbMbQg3FP8Lm5NRhR02SgY94sj8XgPaPMO8k/pMWN9psba+8Vsl25mVYsldFeSTUD6K23WCl6eDymhptaOo54doNHz7v40kBABQ,iv:uEZOMjcyBmSJVdgrt50pSHKYBvjEAWO3ZIOXa0iDuUg=,tag:5RHMo7A7SAH42mrCsaD4Ag==,type:str] + host: ENC[AES256_GCM,data:cgDZ1JvayhYmIOCsxd+GlPnCiI8mfIOz2puP7oG24eU=,iv:BWX2ivgRWYoCa/ctLruft0C73RmTBB0lZ1de5ASHBqs=,tag:G4vD+4n0CD0uRp45NcKFng==,type:str] + password: ENC[AES256_GCM,data:C5dfI2RSDRYCPIHQws+0LTDbuC4sIHVbrbKErm1e4L/SW7Q5TMarnKS4/eHTKuo0MjklUj3E8a7GWYJOH82FnA==,iv:OrYYt4KhEq0z4VmK7NoSYqYsxN40u/egxztJ/Tnm/3w=,tag:t/1QrBV6gK7JdwuXJs5Ktw==,type:str] + username: ENC[AES256_GCM,data:AE0jcxDz,iv:2mNdhHNerUpmfPSD6vCnhG4mvnB4GXl6nEWAbLdyFYc=,tag:qEt5PIu6jX1Td+BD231+0g==,type:str] + virtualhost: ENC[AES256_GCM,data:243PFhLN,iv:GfcuJIy0gKK4gRxnxr3fdkophxJ9N37z1anUtHevjP0=,tag:zfEogI3z3MsMCevgbJM7zg==,type:str] subgraph: - stakingUrl: ENC[AES256_GCM,data:woDzQFINcyCzfFVIJgGrX3yz2ZDNBmBlVYYJSKeVAwDEw032WSqEfRcyvH8J2kpA6FxXtJl0v1rJQKpq3vjUk9Cna1tJgq0XVfnYT0GEEcyMPoYMfLSmSWhzIpRoEMGGBsrJNeSk27VY2i2S6aEUrC+VSIIshwyQVytM,iv:iozSjoiUTwDJ55tvm4t9ETG0AHeNuLZz+UJ31dc7S3w=,tag:0Uj7GrGy/KwkEtA2oYojww==,type:str] - stakingUrlBackup: ENC[AES256_GCM,data:F+u1qw2U96Yk45Ldhu+qjdT/RLv6g+aWtEIbQOxBCdLc0CDXxs+fIn5JkBFdfRqEWzMR/P+tQspvlpIVNdtCDPkvCtRhLScJNWM=,iv:2QoiKnl3cuO/eCVFa6EcHqkNOC8ULR/MzVIXEyaUooI=,tag:cB5M7uD9AG7gigCDQHeY3A==,type:str] - safesBalanceUrl: ENC[AES256_GCM,data:FSBo8HfsdRO0v4YnQZt1eOTiyYWXlFwLfhuRlYqvn9uBT9w5II1LCqoZee1N4qe3sml7WtIcFaQqXIuqd/HPsySWH926xXcDsayua7R+CDTRuNLAr7aSQaYpWvtN43KuUNGVcYsFcfmIt/H5KBik/s0oK+85o8DK9jaY,iv:0BoTfXDmkVclzu04jx3Z/jySWHNpbP5v3J6P5Qr6o1g=,tag:dX775EYVby4H53vwY+a4tg==,type:str] - safesBalanceUrlBackup: ENC[AES256_GCM,data:wOKPFtlStVD0PgnKmZT77Vds/OMMVGf27NzjOfGKLUx+2IZOo48CDUqSSOdI06EuJDpUClipI3u8nv9n7NPzhz8VH+vfBaeGd3HRXw==,iv:G69DTROezfVD78X4NLxWXRnVk89NHrEHQnM8ByY/x50=,tag:Z/PGe9EYucOWwD+41CgZAA==,type:str] - wxhoprTxsUrl: ENC[AES256_GCM,data:hrNMykvK9dTs7qxSLQY4tOTHX7Y4IgqUPFt76E2fWSlp0xdpwCpGyduwzu87lQkrP1/4yGw5NRm/37l2n1rUweOnsYHxXMjuJxnow39K13ccWva8rN8eG5mYg0WM25XOnOD+vf+YMIYZOOeseNnTnimUu5CiZ2ezhr2l,iv:E7KxMfNzAMiEJL8576xqybFEokrlmoQkSwCbK58P2+Q=,tag:OugLOMTgx3q9w5zyPkXGHQ==,type:str] - wxhoprTxsUrlBackup: ENC[AES256_GCM,data:kPBhJ2NDLlbKWISwjvHjLPbh0Wi//Z2yt19kqcWQzsruA//SLXiWlMiAmG3ALxcgEam7Hwj2GVMt7bWiEeVXfyJBfiLa,iv:ZO2YXHZ5UqFLT/rvYrnV3kmomcQ1oieiGu9P3TJXmqo=,tag:KCenllaPEuKWmuWdr4Hjyg==,type:str] + stakingUrl: ENC[AES256_GCM,data:sBE7m5y54oTWg5oI/6VHeKnNA6tod46+eD0xqvhtG9RLXEjae5slndhA5/4FqCN5SERqOGjWfcEoehbyup0VumgtOMIdal42FcaihIFC15tMmovOrVNNcQnRWADmcqJ572TFswbLXMZp4nSphH+hulS/wP2fg35zzNqJ,iv:7Rly+ehL8uOOjdh8bXpmcQ6Iy4cLEzfu4OvbaVom9SI=,tag:Kswi4rwEs3vbFn8m82VqmQ==,type:str] + stakingUrlBackup: ENC[AES256_GCM,data:vOBU0/nBAdnBaPXXytl7qvfHSyt/7KxcnsCgSPdbGeOcurJN52iRQWGew2GjwEPB9Dh1K0I6Y/fe84sUuGpMYrFRNlMoZc9iAno=,iv:Zd3yCuidXt8ZKJJgAncG7SX3Y/6rbfUC2lb+T2ldN4Q=,tag:TCgcU2rfG2t0pQnPljj6Cg==,type:str] + safesBalanceUrl: ENC[AES256_GCM,data:1IowwCpSqbuTtPwgK2XSfOWR+WkjJupO0Xu4hB2xaxN2jeiGNbgiO+HszH3D72ECHwtxd5LKx0iXHeiJb4eCuN2MW695xXK6+/YNNHI3EfJ/D4HKr1LPEpkaI/xWjdhyv8SPscZysS7Zsed7x4xS/AwadtYxsSkcm+VB,iv:8WrNZBV98Ugp50LBbG9o8IsK3krjOApFXAEGB875c8o=,tag:GzForERisqgcffO9OxL1Jw==,type:str] + safesBalanceUrlBackup: ENC[AES256_GCM,data:SW2p9CF+0YQzTEBbpGaRYMPYhEDqg+cgXUZnCYEO24cAVn88SbGRXR+TkWEA0JAC0Pog9a76evpBMWTaMUAa00Mi24+Iok/JuiN7Aw==,iv:8t6npEO6R0HFjac05qEFvaIdGF+nTAwUPxmIz1HaNoQ=,tag:l+8foHSbz8ORnfm0be67/Q==,type:str] + wxhoprTxsUrl: ENC[AES256_GCM,data:t7mg/oC1o16tAO9y4sW2K3fvKh+1mdexjNLQinNYZ6nr6WlEPGu2xfVKHcVaGENojsfRL4uhKU/r7sOD//BbxLubVjNVDZnvw1TejyE4/KwyK9iPRouuUCDtdtAHX9X0qh8Xetbp645ahw+SPG3Y+8n0oCHLDJMTS/sa,iv:KkWhvYHN2iXSF8GeE9kG9cgR9VliB074OPLSZyEUxcY=,tag:t5OD2AbdxQjk4Ri242p07g==,type:str] + wxhoprTxsUrlBackup: ENC[AES256_GCM,data:mIttP+1Lsdevnmd1LLRLVW/rTIgsDNpmTZtHc6kz807WelJJ7jE2WImy1MnRhGYMUo0Ztl0oVJhgPGfTrREKkzOHzuIB,iv:6egK4AV8FmLhm0QGgSrfnf3uX4QTAxhFzth/1RFHtdI=,tag:7e+xTeGFBP6mBmUuB4N0zA==,type:str] sops: - shamir_threshold: 1 kms: [] gcp_kms: [] azure_kv: [] hc_vault: [] age: + - recipient: age1fx5540pah2npkghtwey6r6xzq6nms6z8h9864ml6m289wh0q8g7qw282xp + enc: | + -----BEGIN AGE ENCRYPTED FILE----- + YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBHM0tkS29ncFl3bjN1QjVN + bWR5TkZic3hDRjhnME9ubUpDcWdVeUxqQ2cwCmFyMFgwTW5aQU4wbFRzZjFBeGRI + RlRwUnh4OFErMTdxS2xiUnE3ZE5ROVkKLS0tIHV2aXpPdi9NOS9UQ0puVTFwWlJa + ak5QcFkvQWtpeFJTVmlMQzRjd3dyUE0K7xphpX3F8Qh4QnAOuTU6za9eVrWk4NQW + CuAyTJWTcsMzY7Z9rf14iQSs66bOcAQ1RHTQgNv4XG7Y9mpgcdqsSA== + -----END AGE ENCRYPTED FILE----- - recipient: age12p3svcjz26wqaw2ccxarwd22fuaxdzhn57em9mlyjvh2vvjvresqcejfwk enc: | -----BEGIN AGE ENCRYPTED FILE----- - YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBMMDBoQWRSMEk4dTB4Kytw - NDFhQUYrd0k5R1NMSk4rQnNaajdVaUgydUdBCkMxdlhqSmVRRFpDNmlkejRRZXV3 - WUNpelBHQ2QydXZ4VFlLL1MyTnoyVTAKLS0tIHJGTVpzcHBuTThXQ1h4aDBReERH - U1Y1U3hub0Q1eVlWZS9HU3dYelpGbHcK8zlP32ezjRDORF9Z8OdKib/Hm0gdL4v5 - oakH+9etUi3LoXowDza9ZocCwfgCjmx4WhKFCw/n3eRT0zBk4o+OaQ== + YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBWT2xrU1ZZZDBPR3o1SlFw + M0VtdXFuaFV5NzV4c3EzWDVGZlNiR2NWY1hVCnlDSTkxb21ZUngxblBpQ25MVjYv + TkdMM3BoY3VWTEdGZXpUckN3NnNZaEUKLS0tIGF0U0ZUenp4Y09hM3pGdGRGR1Zt + SXc0Ti85QnB6R0JNWjNoWWpIdkF3NlUKE3VUmc6OKaBcwafJ5S8jzONDI+RLh+Zx + TLqa0gQAFoDmAIKtEpB/gpgPhDGjaEShQLS+OtAFUctgCS/1khG9RQ== -----END AGE ENCRYPTED FILE----- - lastmodified: "2024-04-29T14:29:43Z" - mac: ENC[AES256_GCM,data:zCnYH0GBK2JUV4jEnvqkUPlDqvvnSFTDgXiGEIC6LY5fGuM4ddG9vBGppb62Yz1+GwlE1WXDzEYi6s21dYhbTRINIyc9EQqq3xEJajSqAiH2LTnuqLtifUKTeSuACvqR6Fk/3EVDbNIWfoOqUMRJGABFErvflPg6RXzFw7SsOeE=,iv:p7Bz0nsRoaZqTXBOoQ3LAg2pMvzaalsH9kFUNx1YL6o=,tag:5S7cO3pbkJoisklZ1HgyYw==,type:str] + lastmodified: "2024-05-23T13:59:03Z" + mac: ENC[AES256_GCM,data:C4PSu8of9i8koGuETHDEVbP33RUv0okgbrU/opThrPJhXTb2nlPDUhAYlrwAcfp3vGOvPQcYepEYHQcYbOzTmXjNTLuuE8xke2IfKrU2B3+fqQF4bgYKfv2EoFxHDM95qXuJkfKAoLdmLHkMPa/Wgu2d7bX89zWEUrsOy98b44s=,iv:bmq4tVBGWeJXZjMmnx3jnCKL1IOOQQUiqPWCM1bRqqI=,tag:B2BXO6k7G/j+6aqcY7wCHg==,type:str] pgp: [] unencrypted_suffix: _unencrypted version: 3.8.0 diff --git a/helm/secrets-staging.sops.yaml b/helm/secrets-staging.sops.yaml index 325c54f4..e2c7f825 100644 --- a/helm/secrets-staging.sops.yaml +++ b/helm/secrets-staging.sops.yaml @@ -1,45 +1,54 @@ wallet: - deployerPrivateKey: ENC[AES256_GCM,data:RElyy52nA0/VE2QISVliJkWXeAVjTHpi/UPKDx/xpvbeYkPlRf1MMQWzRfI4y/+cdHGJc8EXuyfMzZLM0vlbdA==,iv:ZKQWRnYijrmO0gK368+4v+3SwlIBHw5LRFGmXCy25IQ=,tag:qlG3R2tjrtKIFulsfUU9XQ==,type:str] - identityPassword: ENC[AES256_GCM,data:FzOLX0kYIJPxpq3kg8T9EzqlfO5Worc=,iv:kw3ugpdN+6BkjmwmveMX+C34GbrcloV1AESw/tj9RsM=,tag:jk8lyAHx1pR8pVMqN+OlGA==,type:str] - hoprdApiToken: ENC[AES256_GCM,data:/CafRsA8+tevF0GuHjK1G7mrACr2zImhiEKgJOA6jhTX22qX83LMtX2nmmJKXBedvvU/3g==,iv:M7a7bX4O6VSjhq5xXNo9YYM7FSg2vwtVXeYVp9vCRTk=,tag:0eCDQXwKuqeRq627ia5TJw==,type:str] + deployerPrivateKey: ENC[AES256_GCM,data:YSbqFo0lY06f/YwbpLORr4OEUI9CK2grE52KpqNJfI92pAsW8e/eMvCZQff9lKIriAVPobUZmRA8RbgzLUlObg==,iv:7Y1FZiWbBwUxm+w8Lwsc1ENnFLEKqYTVcM3LtXLwPf8=,tag:8NiY+R/8/mCjyELuGPCxbA==,type:str] + identityPassword: ENC[AES256_GCM,data:G8BYV1Xh2ZUqNrRtI1Bq+58IwHKearM=,iv:g97XFgztPxdbcsaqDzpXFoAbH44jflxW62TcC/urSkM=,tag:eujRShbzmOzH7mB640az+g==,type:str] + hoprdApiToken: ENC[AES256_GCM,data:oo1BU9BT4MGuqYtzu6plY48EcWgr3cmJAfBykMOudzEJPPW4ugb6vqWlLAlrOEYC9mVM9Q==,iv:eHEh4Ul5Cw8HxbunANrBTLQ0q9PNKyhxgvO9nAcL5bg=,tag:LpwNpPyT9NzsE5rig3n0SQ==,type:str] +#ENC[AES256_GCM,data:/bN4qcaF3C4REQgitRFtffY=,iv:Fvsn8Jnp0zSPZRCl8DHxqVI7dg40nhPICAQnszpoZik=,tag:ZdcNTxyLDbPPdIZITuW71w==,type:comment] ctdapp: postgres: - database: ENC[AES256_GCM,data:ODxeJYkk,iv:jwb3Nfr5XNlUghZIyQGLF0greeyOa4NtcTqtaeQFJDg=,tag:yWr6sXH5m+l/0gVV74ZKWw==,type:str] - host: ENC[AES256_GCM,data:+SHdloilYzdSbrmSnYEbBIcrF4SarcQz,iv:WUiBmyJJy6VUr7Agu3hWQr6clvgNFig0r/64IqnwjuM=,tag:uhHDHjvSO4Oy77oB7NnDyQ==,type:str] - password: ENC[AES256_GCM,data:CJgLp3GQu+rI6qpw5ExMXUcq5HzU5ky/1sTOwAzjXHfsjonJ0A7BRC5MNkTCZgPSuKnIVxCB5sbRYJNPDyf+cg==,iv:pgvbz6RYdEKVBz8/9xvIXA3KJ601gV4PeGJd8Qu9eCU=,tag:NHfcfYdcKWdMwzLH1efp5g==,type:str] - port: ENC[AES256_GCM,data:uYzIYA==,iv:NZWKguD2tNW79P9daEDPfqcz0I28qATYLZhgqg6EKKI=,tag:j4csmgXDdtvyZ2/kSRMFsg==,type:str] - username: ENC[AES256_GCM,data:AZbzwk7q,iv:mdkz40msLPN8fb7xj1VGAfDYB+Y5PsPZoV6Kqb3Ski0=,tag:kiZbzw77P0kNnOi1Z448YA==,type:str] + database: ENC[AES256_GCM,data:BVZc3fdB,iv:9/KciG4PXOnUD7OL8yccwe0e5wc8txiajaNiGmN9LkU=,tag:+9Xq2PxdghMyMXoC3D+AzQ==,type:str] + host: ENC[AES256_GCM,data:x/aX486Lo3MTjANMR7XW9BumY23G+hC8,iv:OvqK5FhF5oVAje9fuT902R1bLLaVTi8au3fDRAZBYsk=,tag:Y5Y3sLdD0Qwy4f+hj9K05w==,type:str] + password: ENC[AES256_GCM,data:4AkaK6xA8R541rr782+TGS06i8K6rBsU59SDSf+ek+WYzwGYOjKQdM/lflp0G9fNq9fi9q2Flp9moDy7dbybvA==,iv:Epecgv2hUWbi+JbRLd2iEEd41i+Yi37kosmlaz8UeTY=,tag:5tqoRlZNnDRXtck6XwY/vw==,type:str] + port: ENC[AES256_GCM,data:pvfJaA==,iv:ShElefgn2+t5nVWnzUCn20HSuEHlZvhtkso90b9fauk=,tag:h1N8vScNa3CosIkNoICVag==,type:str] + username: ENC[AES256_GCM,data:5ryVlszO,iv:zrJp8u4krDji4dyNlJVPBFVAa9WH/jj2piVYypasGL8=,tag:9HG294qr+ty2JAkJhjpi3Q==,type:str] rabbitmq: - celeryBrokerUrl: ENC[AES256_GCM,data:4S8YZejBpAFdxkZMiW9U6WFu7zlWVq1NVnHD9VLbT7vrNc8bTzh/B6CIZ8KkninV/thKSzc8Y+YVe/jMbpcMW52idq0+DkZ2kr4IKBe4XaZC/t/qtunUzmsHhyZ2itfjQ5TpeYaVFwTCLCW7El+hkNxbRsqbAQ==,iv:bpbXe44YiQ4b4ccI4H0mqRIje6+IVdT1f9Fo4rvmd+o=,tag:zPzGdRYoXkyoqJBRjk+NZA==,type:str] - host: ENC[AES256_GCM,data:bbqell7vmOjU0O5y6X4rgbA8KLn5WsAclFxKNFkkBU4=,iv:uEfAWVQhmqiqYB6MRri2mQC+QFyZGOKzfLwYE0ZSTro=,tag:vbAs0Xu9JKLmvuxLPcqTIg==,type:str] - password: ENC[AES256_GCM,data:GHD4VfJVxva7YO6M7i2Xv8W8R2HqMfmuQot6XvEECBvkpyyzeiD9kxVRj+WRJG4y+v6dZ8WVffeamR3MnO+QpQ==,iv:FfSQ4hy953tt6ZXp2F3u26lGBpumicBQL2YvrYPoanQ=,tag:lcmmCiuj+Fyy7c4hlWtEAw==,type:str] - username: ENC[AES256_GCM,data:8kx+G5x7,iv:7Iuaab3j1P0Fa+zvvLk0KiaxiqA7gAR/c0L73o9u7CU=,tag:1AlE0bLsLKj1kKif3sB/eg==,type:str] - virtualhost: ENC[AES256_GCM,data:quiqbqQN,iv:en9oeMNGGXM6oGwkX4KfnHhON/1NIQ2i5OFRAJO7NXQ=,tag:SdveTPa2Hr8JUo9ykl2ehg==,type:str] + celeryBrokerUrl: ENC[AES256_GCM,data:wD44RW5ae2vBj80pw3f+8KGB0sPPUPpJH3cCWmGLN1VKBDj5GXwYw2g3sawZfkV9TWQxmM3uwEs2+AYDHeaTPVu4SD8v5/we35HWBeZofCAru9qWCcV0iGSddDPNOvfIy+7MO8szOVq11dPlDsUYnU/50e+h5A==,iv:aFnCb0FWpCN0QN4HbXETsAGED9VnXMJ3Jj3g1USWtAI=,tag:ebbUx1F+O+1LhM0JCTlZ8g==,type:str] + host: ENC[AES256_GCM,data:vQJeCSpcfjEPIUtO4hddzCISRjaz4j0izzMtjY/P1tU=,iv:AayENCFr9E20Hx67IDKT7GORgpDCXsYQKQv7MpnP3zU=,tag:mMIaz487cVIrDgDwCN+tqw==,type:str] + password: ENC[AES256_GCM,data:V/o5ALusfHIAEUfog2F1VAcj34nJF6FhJzw11DUpzmcmzoW59Ehz5o1bYwGJ2BQ6O1Di8n8Cte5JjOI7zy1bmA==,iv:qiN6RXnl/4Y+9I2OkZng4MbvhX8xt76PHnhAbZU6RJQ=,tag:1inGOBbqbQwTahygkjXp1g==,type:str] + username: ENC[AES256_GCM,data:OqAIlMBH,iv:WrX+6GPjqybbUsz3m8wN4jRkqZDQWUKeDKXp/5P3eBU=,tag:7D4VryqUGpeBzTivsdJFlQ==,type:str] + virtualhost: ENC[AES256_GCM,data:X7AiK8Wr,iv:p0Uo1xGlBmzWsOCrTenE3QdSFs/DJPYQ2g1Nb35hSFM=,tag:wVxKa8yM++RV2HPVs8yLpA==,type:str] subgraph: - stakingUrl: ENC[AES256_GCM,data:UXoyoipM5CVDrvkSb5TVhUVnnUcb1Hfhz7QLH5UvIX+YgUShXwhL+KV/Hkp7CZhk2mPtML04P2RpFNyHx/X3bVINpC01C+vUBVGlsu8G3RkWYm3NZdcu6/EWlTcx5QGsLDg3F6LHmRMEiq6cYQ+kYmDo87e1ZByOOXUb,iv:yQqCJOqDnCEmHScL9IGR1AyVldofsSAEbInmH84kaas=,tag:xS32cZngQ5x5gJLBTads5A==,type:str] - stakingUrlBackup: ENC[AES256_GCM,data:1RFSxyDt+rjjyeBW54hga2UQJ3iyxiWFHSVmJ4KWbsyO7UCa3km0WWMM/RUy8WG1v3jMHMf0mnd6Lv5ROHAE4dWUm+8vV855wt8=,iv:iFiHu8MVDn0986OQqIRcqaUSAn6TZJBrsk+nfsP/ABM=,tag:aGMhZP03QYI5s4AjaiLksw==,type:str] - safesBalanceUrl: ENC[AES256_GCM,data:7yp7I4/JKaWe/rKAndSV9RZjVRnnjrBz5S5Wc+Ju4+etrWmXNP+ZsSu0fqjus3p8vcF/RfCS2i15HLR+Bh8qISGRnVFAMOFHJYiIFqOIAefnGnGJIZTF5yTgMUhoY98dgq77XAuiqtTSDZQ4hmvpFemMM/L1sQFv+GjZ,iv:RcoYo91coC2lW3vDiPF0FTcM+FEC8J8lZ6TFNfZ/3D8=,tag:gTomJ1/hJKhYsASQOZvxZQ==,type:str] - safesBalanceUrlBackup: ENC[AES256_GCM,data:oP6dVIxme8VAukzmhMTY3aCJTGiMtkKhK5Ext/857I3hiIsBhJ4Hv28/+Ys7X7jRdD0h4VnjCVByO3OSygeJAs1Sf9aBQuvCi4WYpQ==,iv:uZwldoiN+wADGtimX05+2/T8irp1O3OA9WyWHke538Y=,tag:f+dbpP/CEm56Xmg1B5PaiA==,type:str] - wxhoprTxsUrl: ENC[AES256_GCM,data:FirJ4hbxjMbou5o6K+0WVCwKYUPhmit+Iy88atrgtPaOYdXEhWzzs2zuIJ+ZnNXJElPMYr9KQf9Rhpn1AIt4drWH23URtfxMhsFZSguTT9CWX+qBnDXlx493LOFDBCufrAwYcXFOyey5AmDIO1WVEJxHfIoqgrrbHNk8,iv:bbHjIS6iCdB+mJ8935eIk0IRV9FJaSavQm/43hvh0/s=,tag:L8ioVhfx//fu2QQAUju9WQ==,type:str] - wxhoprTxsUrlBackup: ENC[AES256_GCM,data:zyc7R1s3EjnoxImzzB0QimkR/YTFp3JH0iy2qcKIhecosyYfXy+/KrHG6DhkFWVWzCmFZV81vmG9fRk2L1XK/kM2Yi1e,iv:+GwEL4ajYTG7OZTU1/kFFHQCMOwq1pUp+mWEvFsByTY=,tag:LoIzQTXVBwegd8faO6qJoQ==,type:str] + stakingUrl: ENC[AES256_GCM,data:R3oT6qp39hbIzJzQXwrO7rU+zb96T5neQqQ+c/LMLD9qn0Cw02qU4u6KobmrzawwBOEIpRRVjOoGiFiMO8PDUwOh5xZIDnk6s0PEhR8PL74CJZNjaZDwt/S/0tty8aoB8gH3hK1Uk6f77rozya96v+0Qkbv2wnPK+nLg,iv:Gbv5ogwaWsTEBDGqTigR5QPJVI6CEIJQOwkkDeq246g=,tag:HM6ptK3hixXhMHlMNW4jOQ==,type:str] + stakingUrlBackup: ENC[AES256_GCM,data:xvqh3/VU9oXHtH6ej14+RP11Tw8wwk+QJh9b3k9vUUyPB36Ecq+sm8JKyLds36Qs/61UHlTPBwy6i+oKegvOIzShqzSZPN9safo=,iv:SX+82FWti3A0PliUUgZoaQiEjhz9MDmfoBCxgefUNX8=,tag:Ck4GT/CKq91CGT9wKewudA==,type:str] + safesBalanceUrl: ENC[AES256_GCM,data:K/dqFhJMKc8pCSiFtcrUqE+G7LEhwi65/67rfGzCiOdjl2Mo9RR4kFI/yNPvauYsycur81zOIQ/efMvlRaqfxFvfRGAOal179BLewV8KscqEVolzamfeW9g35RCtS2yTwFb2XsWTFMFZuobX07QmPr1znXtfExM8nW14,iv:T/h9G5yuL0Q4DZF0PdGpfRT/ENicaDUNDizOjDZU8Fk=,tag:xoYXlnqwHfmFKaO6fQMqgA==,type:str] + safesBalanceUrlBackup: ENC[AES256_GCM,data:t0g6/kq6CNXqL6Su9j+M0lVWqjMMHU44mdFtwVS/yY7Z7t0D77Bqr4BvCbFWBlQ1E2vkIc5iRZ/67ErrH3Ge/R/ocOS2c+NfNVDILQ==,iv:HyRmsnKXmkfyBRLOBBiyyiKuKuFmQh10hPhtxq1FnuA=,tag:vB2HygASXoY8FATgIBW+tA==,type:str] + wxhoprTxsUrl: ENC[AES256_GCM,data:Pr7W99U2r13NZFRw6haifYI38Pse/6lpe5EewSTnhmjRrzV+igrRzPAykCUOwtpqgMO95anxbj0JEeEQWdjBacCjrDuM1AU46wDUUq/ufVMs/X09FePCme8TDHLC6ke/2j5d7Vru7GZQ0LcsfUTYxio2/1ro6Qo4Kqqw,iv:zJtuDEGbizi84IlbY/b8Qk7Nc4eAmf6urODQbXU64f4=,tag:SrR8Dhzm0GWVqvjTqKNjyg==,type:str] + wxhoprTxsUrlBackup: ENC[AES256_GCM,data:l5ErOWItJN8y2ZeplUE5NqyzOMTjhqWTYJjJHGDXAobjQ3AHkGAIGWycGNyLRw0H6enHATdlAbmPLBqPtXtHmYHZLymb,iv:trt2185Yb80q41ieGvGH58npuH0fFSoBYwxVX48mCpc=,tag:VxgafnXrrTG3Cb2bT8bLGw==,type:str] sops: - shamir_threshold: 1 kms: [] gcp_kms: [] azure_kv: [] hc_vault: [] age: + - recipient: age1fx5540pah2npkghtwey6r6xzq6nms6z8h9864ml6m289wh0q8g7qw282xp + enc: | + -----BEGIN AGE ENCRYPTED FILE----- + YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBiOVUwcUpxQ3hTNDgwelBy + Y0RGVXp5MVIwWVdISGtPaVpqV2pCdjNQMjBRCmQwdVBtRFZISG5vUm1tWXpYeDJN + NDZyb3dsQkJ6aVFNUlNVYzdhMkIxM2MKLS0tIFppS0VsQlE1OHBQVkRzRkVjSGxn + MlBDUE1hYnJOVk9CYzloT0loME1SQWcKrn5RO5anAmI0lJH4IsO285N6sNK46/NM + D+3ogpa+95AiuncxB3zCsiq/gfwDqCfA5eVdYeo/ygIyiCGm2018XA== + -----END AGE ENCRYPTED FILE----- - recipient: age12p3svcjz26wqaw2ccxarwd22fuaxdzhn57em9mlyjvh2vvjvresqcejfwk enc: | -----BEGIN AGE ENCRYPTED FILE----- - YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSBMMDBoQWRSMEk4dTB4Kytw - NDFhQUYrd0k5R1NMSk4rQnNaajdVaUgydUdBCkMxdlhqSmVRRFpDNmlkejRRZXV3 - WUNpelBHQ2QydXZ4VFlLL1MyTnoyVTAKLS0tIHJGTVpzcHBuTThXQ1h4aDBReERH - U1Y1U3hub0Q1eVlWZS9HU3dYelpGbHcK8zlP32ezjRDORF9Z8OdKib/Hm0gdL4v5 - oakH+9etUi3LoXowDza9ZocCwfgCjmx4WhKFCw/n3eRT0zBk4o+OaQ== + YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSAyamEzL1VFQjg2Sm9yTFMv + QjE5L0ZlMGMwSXBGaDRrVC9lNlEyaUdCY1drCkd6VXV2dTdKMi92SE1BUmI5Vzdt + Y3JFNnhvRXp3cmJNK3hXdG1tZHZmbWMKLS0tIG94YWRRMXgvUmkwWE5PaktFMkVG + M1ZjcTlDVWYrbUYwQU9DUlN0NVhUY0kKyUI2VVCMfx+squtawdgIvQvgpmMeQOnd + LmVJsOGerMfUsUcOv3p99jgqP2t8vsmxHx7bUe1yIUDr54LSfL/2Hw== -----END AGE ENCRYPTED FILE----- - lastmodified: "2024-05-02T08:47:13Z" - mac: ENC[AES256_GCM,data:XYT2u/WfKcSAN7ymC6YRfGzHKly/HFkOjnBfLJr8lWXoWZrmjNdqMZD8YTVSk9sDAz1hqt+HPm7jNZxFezqqg+fosTwittpkJo/YPd2faZoCoZQF9N88YuIuOKZMc8fw88PdIUG/HRbPSbeWvYNsH3c+V0JFCAHH+KMv6ld4alk=,iv:zlmTLfZwbb+peP/RW9jUnSYecg/Z5ocRVsTANk7KRiU=,tag:tkjwriloWB9p3wqmc2WjrQ==,type:str] + lastmodified: "2024-05-23T13:58:09Z" + mac: ENC[AES256_GCM,data:uYAO0jsPH2b9GbWlG0FzbD/KfGytDhAhDEQZ16YhhR5KZob7Eq1TILtFo6LuZO4EMB7Bk/PZ3GQxo5+9cdzITtzpe3T9zS/NB2WCzii6Qx7FuwE+PfZVM4p9jCxGf9Hf1AFvBBwjfRU6MB3BdWiKYmV5aGq9RfEQBVf03hEQrRI=,iv:jYzrMV04E2IMZAUISB5LKPPlb4kPL2s4MAeETeTdxLc=,tag:J+LHMQ/j+WO8+cBSYnH2uQ==,type:str] pgp: [] unencrypted_suffix: _unencrypted version: 3.8.0 diff --git a/helm/values-prod-blue.yaml b/helm/values-prod-blue.yaml index f2b1ea44..0f13aa23 100644 --- a/helm/values-prod-blue.yaml +++ b/helm/values-prod-blue.yaml @@ -1,6 +1,6 @@ replicas: 5 network: dufour -version: saint-louis-latest +version: "2.1.0" config: | hopr: diff --git a/helm/values-prod-green.yaml b/helm/values-prod-green.yaml index 514d3339..359911f6 100644 --- a/helm/values-prod-green.yaml +++ b/helm/values-prod-green.yaml @@ -1,6 +1,6 @@ replicas: 5 network: dufour -version: 2.1.0-rc.3 +version: "2.1.0" config: | hopr: diff --git a/helm/values-prod.yaml b/helm/values-prod.yaml index fbe8b968..34082b6f 100644 --- a/helm/values-prod.yaml +++ b/helm/values-prod.yaml @@ -12,11 +12,11 @@ backup: ctdapp: core: replicas: 1 - tag: v2.1.10 + tag: v2.2.0 extraEnvVars: FLAG_CORE_DISTRIBUTE_REWARDS: "1" - DISTRIBUTION_MIN_ELIGIBLE_PEERS: "5" + DISTRIBUTION_MIN_ELIGIBLE_PEERS: "100" DISTRIBUTION_MAX_APR_PERCENTAGE: "15.0" GCP_BUCKET: hoprnet-ctdapp-prod @@ -29,4 +29,11 @@ ctdapp: CHANNEL_MAX_AGE_SECONDS: "172800" postman: replicas: 1 - tag: v2.1.10 \ No newline at end of file + tag: v2.2.0 + nodes: + NODE_ADDRESS_1: http://ctdapp-blue-node-1:3001 + NODE_ADDRESS_2: http://ctdapp-blue-node-2:3001 + NODE_ADDRESS_3: http://ctdapp-blue-node-3:3001 + NODE_ADDRESS_4: http://ctdapp-blue-node-4:3001 + NODE_ADDRESS_5: http://ctdapp-blue-node-5:3001 + NODE_ADDRESS_X: http://ctdapp-blue-node-5:3001 \ No newline at end of file diff --git a/helm/values-staging-blue.yaml b/helm/values-staging-blue.yaml index f67622bd..a129b908 100644 --- a/helm/values-staging-blue.yaml +++ b/helm/values-staging-blue.yaml @@ -16,7 +16,6 @@ identityPool: funding: schedule: 20 8 * * 1 - identities: ctdapp-blue-node-1: identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiIxODg5MDczNTE2MzAyZTE0NWM2YjEyZjRmMjZiZTM5MyJ9LCJjaXBoZXJ0ZXh0IjoiNzliZDA2OGQ4N2EyZTI1NWUzY2ViNDQ5Y2M4ZWM4ZGViOGI1YjMzMmJiYzcxMTJhMmNkYmM5NTRmYjkyMmMxMjkwNDU5NTI0NGRlNjQ4MzdkZDFiMmI2ZjUyY2Y3NDg3NGQ3MWFjMDFmMzIxZjE3MGFhZTk2ZWFlZmZmNDhlYzgyNjQ2ODk0N2E4YTRhNTQyM2RhYTQ5MTFkOTM1YzdiNGQwZjQ3ZjMwMTAxYWVjZTdkNzY5OGFjYjIyZGU1OGNhYmUxMDY0ZTU1MDk2NWNiNTAxZjUyYzU2MzQyMDQ1MTFhNTVmZWViZDhkYjkwZWQ0ODVjZGVmMzUwZTFkYTk5YWU2NDUyNmFiMTExODJmNTBiYjExZjQ5NzJlMTJlYWRiODNlZjA4NTIwNjUyMmFjYzRiYmMxZTdlNGRmNTQxMjA3OGE3YzM0MjRmODM3YjdkZjM5MGI0NDkiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiNzM2OTQ1ZmEwZTFjMTQ3MjRmN2Q0YWQ5MjYyOWExYmVmYTlhNDI4MjQ3ZmRmYzI1MTY4MDdlY2MxMTNmMjU0ZCJ9LCJtYWMiOiI4ODgzMzhmZjViNDk3MTJlZjMzMzFiMDlmNTY2NmIwY2IzZDkyNTdhNGQxNjk0M2U3ZjVmODQzY2I1YWIyOTk2In0sImlkIjoiMDdlOTUxMzEtMWU4ZC00YzI5LTk4OTQtZWVkZDU5NDJlMTM2IiwidmVyc2lvbiI6M30=" diff --git a/helm/values-staging.yaml b/helm/values-staging.yaml index 5c0ad62a..74ebae22 100644 --- a/helm/values-staging.yaml +++ b/helm/values-staging.yaml @@ -11,8 +11,8 @@ backup: ctdapp: core: - replicas: 0 - tag: ba586d0 + replicas: 1 + tag: v2.2.0 extraEnvVars: GCP_BUCKET: hoprnet-ctdapp-staging @@ -22,5 +22,12 @@ ctdapp: CHANNEL_FUNDING_AMOUNT: "0.2" CHANNEL_MAX_AGE_SECONDS: "172800" postman: - replicas: 0 - tag: ba586d0 \ No newline at end of file + replicas: 1 + tag: v2.2.0 + nodes: + NODE_ADDRESS_1: http://ctdapp-blue-node-1.ctdapp.svc:3001 + NODE_ADDRESS_2: http://ctdapp-blue-node-2.ctdapp.svc:3001 + NODE_ADDRESS_3: http://ctdapp-blue-node-3.ctdapp.svc:3001 + NODE_ADDRESS_4: http://ctdapp-blue-node-4.ctdapp.svc:3001 + NODE_ADDRESS_5: http://ctdapp-blue-node-5.ctdapp.svc:3001 + NODE_ADDRESS_X: http://ctdapp-blue-node-5.ctdapp.svc:3001 \ No newline at end of file diff --git a/waitlist/__main__.py b/waitlist/__main__.py index c98651d2..e5face05 100644 --- a/waitlist/__main__.py +++ b/waitlist/__main__.py @@ -1,4 +1,6 @@ -from os import environ as env +import asyncio +import os +from datetime import datetime import click from dotenv import load_dotenv @@ -6,19 +8,26 @@ from dune_client.query import QueryBase from .dune_entry import DuneEntry -from .network_waitlist_entry import NetworkWaitlistEntry +from .graphql_providers import ProviderError, SafesProvider from .registration_entry import RegistrationEntry +from .subgraph_entry import SubgraphEntry load_dotenv() dune = DuneClient.from_env() +import logging + +logging.getLogger('gql.transport.aiohttp').setLevel(logging.CRITICAL) def remove_duplicates( - data: list, attribute: str = "safe_address", keep_last: bool = False + data: list, param_list: list[str] = ["safe_address"], keep_last: bool = False ) -> list: _data = data[-1::-1] if keep_last else data - attributes = [getattr(entry, attribute) for entry in _data] + attributes = [] + for entry in _data: + attributes.append("-".join(getattr(entry, param) for param in param_list)) + duplicates_free = [] for attribute in set(attributes): index = attributes.index(attribute) @@ -57,56 +66,87 @@ def applyCOMMrules(nr_waitlist: list, stake_waitlist: list, chunk_sizes: tuple): default="network_register.xlsx", help="Network register file (.xlsx)", ) -@click.option( - "--waitlist", - default="network_waitlist.xlsx", - help="Network waitlist file (.xlsx)", -) @click.option( "--output-file", default="final_waitlist.xlsx", help="Output file (.xlsx)", ) -def main(nrfile: str, waitlist: str, output_file: str): +def main(nrfile: str, output_file: str): # Loading onboarding waitlist (from Dune) - onboarding_data = dune.run_query_dataframe(QueryBase(env.get("DUNE_QUERY_ID"))) - onboardings = DuneEntry.fromDataFrame(onboarding_data) - unique_onboarding = remove_duplicates(onboardings, "safe_address", True) - addresses_from_onboarding = [e.safe_address for e in unique_onboarding] - + dune_query = QueryBase(os.environ.get("DUNE_QUERY_ID")) + onboarding_data = dune.run_query_dataframe(dune_query) + + dune_data = DuneEntry.fromDataFrame(onboarding_data) + dune_unique = remove_duplicates(dune_data, ["safe_address"], True) + unique_dune_safe_addresses = [e.safe_address for e in dune_unique] + + + provider = SafesProvider(os.environ.get("SUBGRAPH_SAFES_BALANCE_URL_BACKUP")) + deployed_safes = list[SubgraphEntry]() + try: + for safe in asyncio.run(provider.get()): + entries = [ + SubgraphEntry.fromSubgraphResult(safe["registeredNodesInNetworkRegistry"]) + ] + deployed_safes.extend(entries) + + except ProviderError as err: + print(f"get_registered_nodes: {err}") + deployed_safes_addresses = [s.safe_address for s in deployed_safes] + running_nodes = sum([s.nodes for s in deployed_safes], []) + + print("\033[1m", end="") + print(f"SubgraphEntry // Loaded {len(deployed_safes_addresses)} entries", end="") + print("\033[0m") # requires refactoring + # Loading registration data (from Andrius) registrations = RegistrationEntry.fromXLSX(nrfile) - unique_registrations = remove_duplicates(registrations, "safe_address", True) - - # Loading network waitlist (from Cryptpad) - network_waitlist = NetworkWaitlistEntry.fromXLSX(waitlist) - eligible_addresses = [e.safe_address for e in network_waitlist if e.eligible] + unique_registrations = remove_duplicates(registrations, ["safe_address","node_address"], True) - print(f"Eligible addresses\t\t{len(eligible_addresses)}") - - # Cleanup registrations to get only valid candidates - waitlist_candidates = [ - e for e in unique_registrations if e.safe_address not in eligible_addresses - ] + waitlist_candidates = unique_registrations print(f"Candidates after cleanup\t{len(waitlist_candidates)}") # Filtering candidates by stake and NFT ownership waitlist = [] for c in waitlist_candidates: - if c.safe_address not in addresses_from_onboarding: + if c.safe_address in unique_dune_safe_addresses: + index = unique_dune_safe_addresses.index(c.safe_address) + candidate = dune_unique[index] + candidate.node_address = c.node_address + + elif c.safe_address in deployed_safes_addresses: + index = deployed_safes_addresses.index(c.safe_address) + deployed_safe = deployed_safes[index] + candidate = DuneEntry( + datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + deployed_safe.safe_address, + "", + deployed_safe.wxHoprBalance, + False, + None, + ) + candidate.node_address = c.node_address + + else: continue - index = addresses_from_onboarding.index(c.safe_address) - candidate = unique_onboarding[index] - candidate.node_address = c.node_address - if candidate.wxHOPR_balance < 10000: + print(f"Low balance: {candidate.safe_address} ({candidate.wxHOPR_balance})") continue if candidate.wxHOPR_balance < 30000 and not candidate.nr_nft: + print( + f"Low balance (NFT): {candidate.safe_address} ({candidate.wxHOPR_balance})" + ) continue if not candidate.node_address.startswith("0x"): + print( + f"Invalid node address: {candidate.safe_address} ({candidate.node_address})" + ) + continue + + if candidate.node_address in running_nodes: continue waitlist.append(candidate) @@ -121,13 +161,12 @@ def main(nrfile: str, waitlist: str, output_file: str): ordered_waitlist = applyCOMMrules(nr_waitlist, stake_waitlist, (20, 10)) print(f"Final waitlist size\t\t{len(ordered_waitlist)}") - # Sanity check - assert len(ordered_waitlist) == len(nr_waitlist) + len(stake_waitlist) - assert len(ordered_waitlist) == (len(remove_duplicates(ordered_waitlist))) - # Exporting waitlist DuneEntry.toDataFrame(ordered_waitlist).to_excel(output_file, index=False) + # Sanity check + assert len(ordered_waitlist) == len(nr_waitlist) + len(stake_waitlist) + assert len(ordered_waitlist) == (len(remove_duplicates(ordered_waitlist, ["safe_address", "node_address"]))) if __name__ == "__main__": main() diff --git a/waitlist/dune_entry.py b/waitlist/dune_entry.py index 9183348d..c84e50ef 100644 --- a/waitlist/dune_entry.py +++ b/waitlist/dune_entry.py @@ -1,4 +1,5 @@ -from pandas import Series, DataFrame +from pandas import DataFrame, Series + from .entry import Entry @@ -13,13 +14,14 @@ def __init__( nft_id: int, ): self.date = date - self.node_address = "" self.safe_address = safe_address self.deployment_tx_hash = deployment_tx_hash self.wxHOPR_balance = wxHOPR_balance self.nr_nft = nr_nft self.nft_id = nft_id + self.node_address = "" + @property def safe_address(self) -> str: return self._safe_address diff --git a/waitlist/entry.py b/waitlist/entry.py index b11c1214..84bc0618 100644 --- a/waitlist/entry.py +++ b/waitlist/entry.py @@ -9,7 +9,7 @@ def fromXLSX(cls, filename: str): @classmethod def fromDataFrame(cls, entries: DataFrame): - entries = [cls.fromPandaSerie(entry) for _, entry in entries.iterrows()] + entries = sum([cls.fromPandaSerie(entry) for _, entry in entries.iterrows()], []) entries = [entry for entry in entries if entry is not None] # write in bold @@ -23,9 +23,13 @@ def fromDataFrame(cls, entries: DataFrame): def fromPandaSerie(cls, entry: Series): items: dict[str, str] = cls._import_keys_and_values() - return cls( + return [cls( **{key: entry[value] for key, value in items.items() if value in entry} - ) + )] + + @classmethod + def _import_keys_and_values(self) -> dict[str, str]: + raise NotImplementedError def __str__(self): attributes = [ diff --git a/waitlist/graphql_providers.py b/waitlist/graphql_providers.py new file mode 100644 index 00000000..e040b62f --- /dev/null +++ b/waitlist/graphql_providers.py @@ -0,0 +1,122 @@ +from pathlib import Path +from typing import Union + +from gql import Client, gql +from gql.transport.aiohttp import AIOHTTPTransport +from gql.transport.exceptions import TransportQueryError +from graphql.language.ast import DocumentNode + + +class ProviderError(Exception): + pass + + +class GraphQLProvider: + def __init__(self, url: str): + transport = AIOHTTPTransport(url=url) + self.pwd = Path(__file__).parent + self._client = Client(transport=transport) + self._default_key = None + + #### PRIVATE METHODS #### + def _load_query(self, path: Union[str,Path]) -> DocumentNode: + """ + Loads a graphql query from a file. + :param path: Path to the file. The path must be relative to the ct-app folder. + :return: The query as a gql object. + """ + with open(self.pwd.joinpath(path)) as f: + return gql(f.read()) + + async def _execute(self, query: DocumentNode, variable_values: dict): + """ + Executes a graphql query. + :param query: The query to execute. + :param variable_values: The variables to use in the query (dict)""" + try: + return await self._client.execute_async( + query, variable_values=variable_values + ) + except TransportQueryError as err: + raise ProviderError(err.errors[0]["message"]) + + async def _test_query(self, key: str, **kwargs) -> bool: + """ + Tests a subgraph query. + :param key: The key to look for in the response. + :param kwargs: The variables to use in the query (dict). + :return: True if the query is successful, False otherwise. + """ + vars = {"first": 1, "skip": 0} + vars.update(kwargs) + response = await self._execute(self._sku_query, vars) + + return response and key in response + + async def _get(self, key: str, **kwargs) -> dict: + """ + Gets the data from a subgraph query. + :param key: The key to look for in the response. + :param kwargs: The variables to use in the query (dict). + :return: The data from the query. + """ + page_size = 1000 + skip = 0 + data = [] + + while True: + vars = {"first": page_size, "skip": skip} + vars.update(kwargs) + + response = await self._execute(self._sku_query, vars) + + content = response.get(key, []) + data.extend(content) + + skip += page_size + if len(content) < page_size: + break + + return data + + #### DEFAULT PUBLIC METHODS #### + async def get(self, key: str = None, **kwargs): + """ + Gets the data from a subgraph query. + :param key: The key to look for in the response. If None, the default key is used. + :param kwargs: The variables to use in the query (dict). + :return: The data from the query. + """ + + if key is None and self._default_key is not None: + key = self._default_key + else: + self.warning( + "No key provided for the query, and no default key set. Skipping query..." + ) + return [] + + return await self._get(key, **kwargs) + + async def test(self, **kwargs): + """ + Tests a subgraph query using the default key. + :param kwargs: The variables to use in the query (dict). + :return: True if the query is successful, False otherwise. + """ + if self._default_key is None: + self.warning( + "No key provided for the query, and no default key set. Skipping test query..." + ) + return False + + return await self._test_query(self._default_key, **kwargs) + + +class SafesProvider(GraphQLProvider): + def __init__(self, url: str): + super().__init__(url) + self._default_key = "safes" + self._sku_query = self._load_query( + "./safes_balance.graphql" + ) \ No newline at end of file diff --git a/waitlist/registration_entry.py b/waitlist/registration_entry.py index 2daea37a..fd3a0842 100644 --- a/waitlist/registration_entry.py +++ b/waitlist/registration_entry.py @@ -1,4 +1,5 @@ from pandas import Series + from .entry import Entry @@ -10,18 +11,16 @@ def __init__( safe_address: str, node_address: str, nr_nft: str, - communication_service: str, + # communication_service: str, telegram: str, - email: str, ): self.time = time self.participant = participant self.safe_address = safe_address self.node_address = node_address self.nr_nft = nr_nft - self.communication_service = communication_service + # self.communication_service = communication_service self.telegram = telegram - self.email = email @property def safe_address(self) -> str: @@ -44,24 +43,37 @@ def __repr__(self): "RegistrationEntry(" + f"{self.participant}, " + f"{self.safe_address}, " - + f"{self.node_address}, " + + f"{self.node_address}" + ")" ) @classmethod def fromPandaSerie(cls, entry: Series): - return cls( - time=entry["Time"], - participant=entry["Participant"], - safe_address=entry["What is your HOPR safe address?"], - node_address=entry["What is your Node address"], - nr_nft=entry["Do you already have the Network Registry NFT?"], - communication_service=entry[ - "How would you like to be informed once you're able to join the network?" - ], - telegram=entry["What is your Telegram handle?"], - email=entry["What is your e-mail?"], - ) + node_addresses = entry[ + "What is your Node address? (If you want to add multiple, just include one node per row)" + ].replace(" ", "\n").split("\n") + + + instances = [] + for address in node_addresses: + address = address.strip().lower() + if address == "": + continue + + instance = cls( + time=entry["Time"], + participant=entry["Participant"], + safe_address=entry["What is your HOPR safe address?"], + node_address=address, + nr_nft=entry["Do you already have the Network Registry NFT?"], + # communication_service=entry[ + # "How would you like to be informed once you're able to join the network?" + # ], + telegram=entry["What is your Telegram handle?"], + ) + + instances.append(instance) + return instances @classmethod def _import_keys_and_values(self) -> dict[str, str]: @@ -71,8 +83,6 @@ def _import_keys_and_values(self) -> dict[str, str]: "safe_address": "What is your HOPR safe address?", "node_address": "What is your Node address", "nr_nft": "Do you already have the Network Registry NFT?", - "communication_service": "How would you like to be informed once you're " - + "able to join the network?", + # "communication_service": "How would you like to be informed once you're able to join the network?", "telegram": "What is your Telegram handle?", - "email": "What is your e-mail?", } diff --git a/waitlist/safes_balance.graphql b/waitlist/safes_balance.graphql new file mode 100644 index 00000000..6deb9c05 --- /dev/null +++ b/waitlist/safes_balance.graphql @@ -0,0 +1,15 @@ +query ($first: Int!, $skip: Int!) { + safes(first: $first, skip: $skip, where: {registeredNodesInNetworkRegistry_: {node_not: ""}}) { + registeredNodesInNetworkRegistry { + node { + id + } + safe { + id + balance { + wxHoprBalance + } + } + } + } +} \ No newline at end of file diff --git a/waitlist/subgraph_entry.py b/waitlist/subgraph_entry.py new file mode 100644 index 00000000..b1ea8e98 --- /dev/null +++ b/waitlist/subgraph_entry.py @@ -0,0 +1,39 @@ +class SubgraphEntry: + def __init__( + self, + nodes: list[str], + wxHoprBalance: str, + safe_address: str, + ): + self.nodes = nodes + self.wxHoprBalance = wxHoprBalance + self.safe_address = safe_address + + @classmethod + def fromSubgraphResult(cls, nodes: dict): + safe = nodes[0]["safe"] + return cls( + [node["node"]["id"] for node in nodes], + float(safe["balance"]["wxHoprBalance"]), + safe["id"], + ) + + def has_address(self, address: str): + return self.node_address == address + + def __eq__(self, other): + return ( + self.nodes == other.nodes + and self.wxHoprBalance == other.wxHoprBalance + and self.safe_address == other.safe_address + ) + + def __str__(self): + return ( + f"SubgraphEntry(nodes={self.nodes}, " + + f"wxHoprBalance={self.wxHoprBalance}, " + + f"safe_address={self.safe_address}), " + ) + + def __repr__(self): + return str(self) \ No newline at end of file From 2bf83ff8be4fb3e0a7011dfc78ef32153121800f Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Mon, 27 May 2024 15:43:06 +0200 Subject: [PATCH 17/27] Fix version parsing when returned value is `UNKNOWN` (#522) --- ct-app/core/model/peer.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/ct-app/core/model/peer.py b/ct-app/core/model/peer.py index 9714e259..8a1cee15 100644 --- a/ct-app/core/model/peer.py +++ b/ct-app/core/model/peer.py @@ -46,8 +46,11 @@ def version(self) -> Version: @version.setter def version(self, value: str or Version): - if isinstance(value, str): - value = Version(value) + if not isinstance(value, Version): + try: + value = Version(value) + except Exception: + value = Version("0.0.0") self._version = value From 8af81c488b77244f0c639c8d28929b00f5b0a2b5 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Mon, 27 May 2024 16:58:13 +0200 Subject: [PATCH 18/27] Fix api endpoints to fund and open channels (#523) --- ct-app/core/components/hoprd_api.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ct-app/core/components/hoprd_api.py b/ct-app/core/components/hoprd_api.py index 17270016..062083a6 100644 --- a/ct-app/core/components/hoprd_api.py +++ b/ct-app/core/components/hoprd_api.py @@ -143,7 +143,7 @@ async def open_channel(self, peer_address: str, amount: str): body = OpenChannelBodyRequest(amount, peer_address) is_ok, response = await self.__call_api( - ChannelsApi, "channels_open_channel", body=body + ChannelsApi, "open_channel", body=body ) return response.channel_id if is_ok else None @@ -157,7 +157,7 @@ async def fund_channel(self, channel_id: str, amount: float): """ body = FundBodyRequest(amount=f"{amount:.0f}") is_ok, _ = await self.__call_api( - ChannelsApi, "fund_channel", channelid=channel_id, body=body + ChannelsApi, "fund_channel", channel_id=channel_id, body=body ) return is_ok @@ -169,7 +169,7 @@ async def close_channel(self, channel_id: str): :return: bool """ is_ok, _ = await self.__call_api( - ChannelsApi, "close_channel", channelid=channel_id + ChannelsApi, "close_channel", channel_id=channel_id ) return is_ok From c29dae4245587083ea4cfda5d909786a0ff91e4c Mon Sep 17 00:00:00 2001 From: ausias-armesto Date: Wed, 29 May 2024 12:30:17 +0200 Subject: [PATCH 19/27] Remove legacy nodes (#524) --- helm/helmfile.yaml | 13 --- helm/values-prod-green.yaml | 51 ++++++------ helm/values-prod-legacy.yaml | 148 ----------------------------------- helm/values-prod.yaml | 2 - helm/values-staging.yaml | 2 - 5 files changed, 26 insertions(+), 190 deletions(-) delete mode 100644 helm/values-prod-legacy.yaml diff --git a/helm/helmfile.yaml b/helm/helmfile.yaml index b38463e0..7ecba761 100644 --- a/helm/helmfile.yaml +++ b/helm/helmfile.yaml @@ -32,19 +32,6 @@ releases: - environmentName: {{ .Environment.Name }} secrets: - secrets-{{ .Environment.Name }}.sops.yaml -- name: hoprd-ctdapp - namespace: ctdapp - chart: hoprassociation/cluster-hoprd - condition: legacy-nodes.enabled - version: 0.3.1 - wait: true - timeout: 5 - values: - - values-common.yaml - - values-prod.yaml - - values-prod-legacy.yaml - secrets: - - secrets-{{ .Environment.Name }}.sops.yaml - name: ctdapp-blue-node namespace: ctdapp chart: hoprassociation/cluster-hoprd diff --git a/helm/values-prod-green.yaml b/helm/values-prod-green.yaml index 359911f6..ab794ac3 100644 --- a/helm/values-prod-green.yaml +++ b/helm/values-prod-green.yaml @@ -17,33 +17,34 @@ identityPool: schedule: 10 8 * * 1 identities: + # The below nodes are in old safe address (0x4AFa6a5265ae7Ba332e886Be3BCe5b16c861dd9f) and need to be migrated to new safe address (0x6f835DeD9E11B859DE87bACBbec9E2BE13Fe0190) ctdapp-green-node-1: - identityFile: "" - peerId: "" - nativeAddress: "" - safeAddress: "" - moduleAddress: "" + identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiI3YjhjYjkwZjY2YzAxZDdkOWU4OWJhYTA1NzY5ZDQ2NyJ9LCJjaXBoZXJ0ZXh0IjoiMjc4MTdhMzA5MzAyOGFkMmYyMmUzN2JhZjEzMDQ0NDI4MmJkMGE3MGRjMzM0ODk0YTQ2OGZkZDkzZWQ2MDNlOTMxYTEyYmZjMmViMjk2YjY5ODFhZWE0ZWIyOWMyZjk2ODk2YjU5MzQ2NmQ5N2E3ZmZkYjlhZWRjYjg5ZTQ3OGU0ODVhMzQwNGM5ODVlOTBlMzM5MjNkMWJmNGYxZGZkMDI1Zjg2NWE1YWY2MDJlZjM5NjY4Njk0ZWZhNmYxYWIwYzcxMzNhYTI5NjUwMjQ3MWQ3NWY5YmY4ZGQ0N2RjZjkwNzI5MzVlNDAyNGVjNjAyNjVlZTdhMDEyMDE1NWIwN2UzODQ5YmFhMDM2N2JlOTkyZGMxMTNkYTgzMTRhMGRiNDQxNGJlYzIyMGI4OGZkOWEzOTllZGRkZmU4YmZlNTFiNjA1OGVjNmZhNzNjNzhjMGYyOGZjODkiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiOGExNWVjNzY3ZDBhMWIyNTM2NzZjNTY1MjE2ZmY4NzJkZmE4MTExZjFhZDhmZTUzODNmMGM4NzM2M2ZiYTczMCJ9LCJtYWMiOiI1ODczNWRlNjQzZjI1YWM1MGRkZDkyNzYxMzFhNGFkNjgyZGEwMWM5OWU4OTA3NTUzOTcwMWJkYzEyYmYwZTlkIn0sImlkIjoiNWE3ZjlhMDgtZTBjZS00ZmQ1LWE2MGUtNzNhZDY5YTllMTcwIiwidmVyc2lvbiI6M30=" + peerId: "12D3KooWL16nW1Z2dLvyZWzr9ZZwoLTeuSfaKSeX2BjucHwSoEwJ" + nativeAddress: "0xd30f8f6e5865d7ec947e101b1d6a183e9776ba40" + safeAddress: "0x4AFa6a5265ae7Ba332e886Be3BCe5b16c861dd9f" + moduleAddress: "0x4c28c1e308869cC1b2F5329A4c1F480efe1506d6" ctdapp-green-node-2: - identityFile: "" - peerId: "" - nativeAddress: "" - safeAddress: "" - moduleAddress: "" + identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiJhNjM1Yjc3NjIzY2Q3ZGEzMzY4MWY4YzFlZmE4MzFjMCJ9LCJjaXBoZXJ0ZXh0IjoiNzEzYTFjMGJmYjQ3ODM0ZWZiNGM4MzBhNTAyNTA1OWRkOTc3MDc0NmM0M2YxMjkxYzZkYWM4ZTg1YzMxZmVjOWFhNTQyYjM3NTBkMTRjNzczY2U3N2VjNmYzOWEwMjhjMTBiMmU0Nzg3ODE1ZTFkYjhjMWQ3OWI3ZTZlMTMxYjVmNDY3ZGQ5OTFhMDIwNDMwOTE2N2YyZWRkMTM4M2VkNWQ1NDAwMDdiMzllNWMwYWE1YTU1NjA4ZmUzOWY5ZTMxNWRlMTE5NGVhOTQ0MTJmY2I4YTdmN2JiYzlhZmUyNjNiMWVmMTI5OTc5YTVjMzA1NGUwYjI3N2QxMWZkZGRlY2ZjYjE2YWU2NmQ2NDczYWMzNTA0ZTUzMjViZmZkMGI2Yzc0MzIyZjkyZjE1MGZlYjEyZTBjYTZhNWQwMjE4ZDRlYWUxMWNlY2IzZTMxNjE5OWI2ZjI3YzAiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiMTRkOWY1OWI2ZjZiMjUwMjVjYzY4ZGYyZWFkZGM3ZDFjNTNjMzQ1OTczOTkwNDUyOTdhYzE3Yjg0NTEzYTU1ZCJ9LCJtYWMiOiJiYzQ3MTFhNmIxNGM3YWVlYmEwYzFjZmM2ODU3OWE0YjBmYWYyNjdkNjBhNzQ3YTU5ZmY5ZmE5YjYyNThiMGMwIn0sImlkIjoiYmRmNDZmYTctYjE3Zi00MjQ0LTgzMTgtYTE0N2E0ZDE2NmUzIiwidmVyc2lvbiI6M30=" + peerId: "12D3KooWH9rfYNKMkNncYJxS7BH41ThPZUYe3FNkbfmJAa4n5r3x" + nativeAddress: "0x5a5bf3d3ce59cd304f198b86c1a78adfadf31f83" + safeAddress: "0xDf9BE8bdB5AE4a130E861E5158C95667E7b2C0CB" + moduleAddress: "0x3aAB0c84CcBbd55cD217A523e1b89988EBF4f30a" ctdapp-green-node-3: - identityFile: "" - peerId: "" - nativeAddress: "" - safeAddress: "" - moduleAddress: "" + identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiJkYmM1NDVlNDQ1NDRjZDFmMTlmMzk1YmNkMWVlMTJlYSJ9LCJjaXBoZXJ0ZXh0IjoiOTg1OGE2ODI3ZTU4YzZjNjI1ZGM4YTEzM2JhZjAyZDk1OGE1OWFhY2RmZjQ0ZDY3OWJjODMzNzE2N2FjZmMwYTU3YjdlYTk5MmQwNmJiZjkwZmQ1ODA5YTQyNWMzZTZmYjAyMTg5YzRiMjg4YmUxY2ZhYzBlYzQ1MWRlMTNkNTIxNDgzZjljNTRhMDNkMzMzODllMDdhMjE5YmZhYjgxNzhhNDdlMjBlZGFiOTU2N2RjNWYyMmU0Y2RkZjhmNTQzYTdjMjlmYjRiZWU5YmY5MDFhYzJiOTNmZDFiZmE4NjVjM2E1NmQ5YzcyNDM2OWU4ZDc5ZGRiMDQwMjRhZDdmNzcyNjE0Mzc2MGEzMGI2MzU3NTU4NjBlNzA0MDBhMGUxNjcxNDgwNzAxNzA1MTE0Yzk4ZDlmNWVkMDlkYWVjYzA1YmM5MDA4OGM5YTllMDBhYTQ2ODJiYTQiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiZGVlNGVjMzI3NzYzNTE2YWVjZjAwNGFlMTZiZWZkNTQzMjIzYzhlM2Q0ODIwODEyMGJhYmQwZjM4YTM3MDY4ZiJ9LCJtYWMiOiJlMDlkM2FmYTAzMjI4MmQ2NzA4N2I3YWNiODRkZTM4ZDdlODMyNjY2ZDJmYmYxMDY5ODE3Y2ZiZTZmZWI0ZDc3In0sImlkIjoiYmFhZjYzMjQtYzcwNi00ZDVlLWE3ODYtZmI4OGQ2MzI0ZDVjIiwidmVyc2lvbiI6M30=" + peerId: "12D3KooWNYi2kG5cdeEUBvjemZRUkPVmAeXsSGVrX9QHnEiMfh8w" + nativeAddress: "0xa4642c066c1f8927db9d34abab599af784a2cff0" + safeAddress: "0xc5E2D5bA66916EF8413a87e3098117C6aC596597" + moduleAddress: "0x448e1116047b452CC582625a954460264D5Ad637" ctdapp-green-node-4: - identityFile: "" - peerId: "" - nativeAddress: "" - safeAddress: "" - moduleAddress: "" + identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiI5MmViNmE1Y2JkZTIyYTdlYTZhYjg2YzVmYmMzMzU1OCJ9LCJjaXBoZXJ0ZXh0IjoiN2IzNGU5YjY0OTFkYzQzNmE1NDRhMzUwZmVkNGIwMWZhOTFkOWZjNzk4OTYzNWVjYmZkYTJlM2U1ODIyMTlkNGY1ZDJlMTNhYWYzNTRkNGJkNjg0OGM1Yzg1N2QxMDQxNGEyNDg4ZjI4ZmM0YzYxZTM4MmU4ZGRjNjA2MjEyMTY0ZDIzMWY2NGE0YjU3MDFiM2UwMGE0OTNiMjYzMGYwYzUzZDU2Nzc0NmRhOTRlM2ZkOWNiNTUxY2VjYmY1NmIzMGJhZDkwODVjZjI5OTRhZDgyOTgyZWNhNzZmNTg4YjgzMTMxN2VjM2MxYjE5ODcwZGM1NDZkZjQ4ZjU2NDNhZTFkZTAyZmNlZmI5MWQyNGI5ZWZkOWQ5YjhmNGVlOTVhZDZlYTM2MzhjNThkYWRkODJmZTViMjk0MzFkZmMxZDdhN2M4NTY5NjJhMzc2OGNlYmMyN2FjZGYiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiYmZhMzZjMDNkZjg4ZTc2NmZlNGMyNmZmZTNmNjQ5NTFlMzRmMjdhZWU5ZmY0MjM5YTdmMDQxZTI4NzRhZTExMCJ9LCJtYWMiOiIxYjk3ZmYzN2Y3YzFkY2MxMzZkOGVjZjdiODBjZGMwNjM3NTE1M2IwOGEzYTFmYjk4YzFlNGNlMTA4YTY1ZDU4In0sImlkIjoiMzZiMDY0NTgtYzFlMC00ODg0LTk3NzctNTExYmIwMTMyOTk1IiwidmVyc2lvbiI6M30=" + peerId: "12D3KooWGyY39vD8J2VGEDjTCD3eEyvV4YrnKM9NCQa6SYJKczrR" + nativeAddress: "0xcbe8726c80cc0d7751b9545dd5a4b5b0e53e383d" + safeAddress: "0x5445A497292C8E669e7d3419BE68DE23c450c56F" + moduleAddress: "0xB32Db6FE369dF1Ee0E1E9bE78c4b488eaB361d6f" ctdapp-green-node-5: - identityFile: "" - peerId: "" - nativeAddress: "" - safeAddress: "" - moduleAddress: "" + identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiI0YjcxNDJkZGUwMDA5ODhjYjI1YTJhZDRkNzRlNzIyOSJ9LCJjaXBoZXJ0ZXh0IjoiMDE1NzgxNzFkNzkwYTUwZDQ2ODQ2YTZhYzYxMjYwNjIzZmY4YzllMDIzM2JlYmFiYWZhOTliZGE2NDE1YTA2ZjhiNzc0MjE5MWRmNzdhNzRiMGIzYzc1NGE2MWU2ZGQ5Yjk0NTM2NWIxYmY5MTkyOTU0NDdjNDE3YzczNTJiODE2ZDk5ZjZlMmQyMmIxODA3MzBlNzhiNTAxYWMyM2RkYmNiZWNlZmY2NTY4NWYyOGQ4N2NkZjY2NWIwYTM2YmM2ZDZkOTI2MDRkYzUzNzJlMWY4Njg1ZWUyNmM4YjhlNDI5N2MwY2FiZWNiMDIwOTk4Y2UyZWU2NGFjODI4ZDc0OGVlNDU2ZDFiY2ZkOTZiYTI3MjAzNzg1ODQxMGRhZjRmMjI5NzIyZGY5MzkxMTEyMWNlOWVjMzliNGVlNWEzMjU5NzI1NzAwZGU0NWMwZjAxYWVjYzM4MzQiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiOTYxYWY0ZjM1YjliOGJhNWJlNGI0OGU3NGY1NWE1MTI0MjI0ODI2Y2M1NzY1MmExNTcyMjY5ZjBmNzg2ODY2YiJ9LCJtYWMiOiJlMzFiYmQxM2YyZWM0ZTA5ZWE2NzcxZTAzZDc5YjkwYzdhZGVjNzM1M2E0YTQzNTBlYzk3ZjU4NGM5ZDliNzgzIn0sImlkIjoiMjJjOWRlN2EtNTVhMy00YWRiLWE3ZTUtODUxOWJkNzJiZDVkIiwidmVyc2lvbiI6M30=" + peerId: "12D3KooWB1bPdu9Q5w2nzKkaCoE9gq9j8bgd3c8iVu81ypSu5WqB" + nativeAddress: "0x764d3162a4024c5cba8817446ef563b27aa57598" + safeAddress: "0x7f30E4902606291De7518f80E0863a944a80eB41" + moduleAddress: "0x221ab86f3fEF58d8e018B6c1fe5d1768925b4BEF" diff --git a/helm/values-prod-legacy.yaml b/helm/values-prod-legacy.yaml deleted file mode 100644 index dcfae3e3..00000000 --- a/helm/values-prod-legacy.yaml +++ /dev/null @@ -1,148 +0,0 @@ -replicas: 5 -network: dufour -version: 2.0.8 -supportedRelease: providence - -config: | - host: - address: !IPv4 0.0.0.0 - port: 9091 - identity: - file: "/app/hoprd-db/.hoprd.id" - password: "" - private_key: - db: - data: "/app/hoprd-db" - initialize: true - force_initialize: false - inbox: - capacity: 512 - max_age: 900 - excluded_tags: - - 0 - api: - enable: true - auth: !Token "" - host: - address: !IPv4 0.0.0.0 - port: 3001 - strategy: - on_fail_continue: true - allow_recursive: false - finalize_channel_closure: true - strategies: - heartbeat: - variance: 2000 - interval: 20000 - threshold: 60000 - network_options: - min_delay: 1 - max_delay: 300 - quality_avg_window_size: 25 - quality_bad_threshold: 0.2 - quality_offline_threshold: 0.5 - quality_step: 0.1 - ignore_timeframe: 600 - backoff_exponent: 1.5 - backoff_min: 2 - backoff_max: 300 - healthcheck: - enable: true - host: 0.0.0.0 - port: 8080 - protocol: - ack: - timeout: 15 - heartbeat: - timeout: 15 - msg: - timeout: 15 - ticket_aggregation: - timeout: 15 - network: dufour - chain: - announce: true - provider: http://gnosis-rpc-provider.rpc-provider.svc:8545 - check_unrealized_balance: true - safe_module: - safe_transaction_service_provider: - safe_address: - addr: - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - module_address: - addr: - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - - 44 - test: - announce_local_addresses: false - prefer_local_addresses: false - use_weak_crypto: false - -identities: - hoprd-ctdapp-1: - identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiI3YjhjYjkwZjY2YzAxZDdkOWU4OWJhYTA1NzY5ZDQ2NyJ9LCJjaXBoZXJ0ZXh0IjoiMjc4MTdhMzA5MzAyOGFkMmYyMmUzN2JhZjEzMDQ0NDI4MmJkMGE3MGRjMzM0ODk0YTQ2OGZkZDkzZWQ2MDNlOTMxYTEyYmZjMmViMjk2YjY5ODFhZWE0ZWIyOWMyZjk2ODk2YjU5MzQ2NmQ5N2E3ZmZkYjlhZWRjYjg5ZTQ3OGU0ODVhMzQwNGM5ODVlOTBlMzM5MjNkMWJmNGYxZGZkMDI1Zjg2NWE1YWY2MDJlZjM5NjY4Njk0ZWZhNmYxYWIwYzcxMzNhYTI5NjUwMjQ3MWQ3NWY5YmY4ZGQ0N2RjZjkwNzI5MzVlNDAyNGVjNjAyNjVlZTdhMDEyMDE1NWIwN2UzODQ5YmFhMDM2N2JlOTkyZGMxMTNkYTgzMTRhMGRiNDQxNGJlYzIyMGI4OGZkOWEzOTllZGRkZmU4YmZlNTFiNjA1OGVjNmZhNzNjNzhjMGYyOGZjODkiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiOGExNWVjNzY3ZDBhMWIyNTM2NzZjNTY1MjE2ZmY4NzJkZmE4MTExZjFhZDhmZTUzODNmMGM4NzM2M2ZiYTczMCJ9LCJtYWMiOiI1ODczNWRlNjQzZjI1YWM1MGRkZDkyNzYxMzFhNGFkNjgyZGEwMWM5OWU4OTA3NTUzOTcwMWJkYzEyYmYwZTlkIn0sImlkIjoiNWE3ZjlhMDgtZTBjZS00ZmQ1LWE2MGUtNzNhZDY5YTllMTcwIiwidmVyc2lvbiI6M30=" - peerId: "12D3KooWL16nW1Z2dLvyZWzr9ZZwoLTeuSfaKSeX2BjucHwSoEwJ" - nativeAddress: "0xd30f8f6e5865d7ec947e101b1d6a183e9776ba40" - safeAddress: "0x4AFa6a5265ae7Ba332e886Be3BCe5b16c861dd9f" - moduleAddress: "0x4c28c1e308869cC1b2F5329A4c1F480efe1506d6" - hoprd-ctdapp-2: - identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiJhNjM1Yjc3NjIzY2Q3ZGEzMzY4MWY4YzFlZmE4MzFjMCJ9LCJjaXBoZXJ0ZXh0IjoiNzEzYTFjMGJmYjQ3ODM0ZWZiNGM4MzBhNTAyNTA1OWRkOTc3MDc0NmM0M2YxMjkxYzZkYWM4ZTg1YzMxZmVjOWFhNTQyYjM3NTBkMTRjNzczY2U3N2VjNmYzOWEwMjhjMTBiMmU0Nzg3ODE1ZTFkYjhjMWQ3OWI3ZTZlMTMxYjVmNDY3ZGQ5OTFhMDIwNDMwOTE2N2YyZWRkMTM4M2VkNWQ1NDAwMDdiMzllNWMwYWE1YTU1NjA4ZmUzOWY5ZTMxNWRlMTE5NGVhOTQ0MTJmY2I4YTdmN2JiYzlhZmUyNjNiMWVmMTI5OTc5YTVjMzA1NGUwYjI3N2QxMWZkZGRlY2ZjYjE2YWU2NmQ2NDczYWMzNTA0ZTUzMjViZmZkMGI2Yzc0MzIyZjkyZjE1MGZlYjEyZTBjYTZhNWQwMjE4ZDRlYWUxMWNlY2IzZTMxNjE5OWI2ZjI3YzAiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiMTRkOWY1OWI2ZjZiMjUwMjVjYzY4ZGYyZWFkZGM3ZDFjNTNjMzQ1OTczOTkwNDUyOTdhYzE3Yjg0NTEzYTU1ZCJ9LCJtYWMiOiJiYzQ3MTFhNmIxNGM3YWVlYmEwYzFjZmM2ODU3OWE0YjBmYWYyNjdkNjBhNzQ3YTU5ZmY5ZmE5YjYyNThiMGMwIn0sImlkIjoiYmRmNDZmYTctYjE3Zi00MjQ0LTgzMTgtYTE0N2E0ZDE2NmUzIiwidmVyc2lvbiI6M30=" - peerId: "12D3KooWH9rfYNKMkNncYJxS7BH41ThPZUYe3FNkbfmJAa4n5r3x" - nativeAddress: "0x5a5bf3d3ce59cd304f198b86c1a78adfadf31f83" - safeAddress: "0xDf9BE8bdB5AE4a130E861E5158C95667E7b2C0CB" - moduleAddress: "0x3aAB0c84CcBbd55cD217A523e1b89988EBF4f30a" - hoprd-ctdapp-3: - identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiJkYmM1NDVlNDQ1NDRjZDFmMTlmMzk1YmNkMWVlMTJlYSJ9LCJjaXBoZXJ0ZXh0IjoiOTg1OGE2ODI3ZTU4YzZjNjI1ZGM4YTEzM2JhZjAyZDk1OGE1OWFhY2RmZjQ0ZDY3OWJjODMzNzE2N2FjZmMwYTU3YjdlYTk5MmQwNmJiZjkwZmQ1ODA5YTQyNWMzZTZmYjAyMTg5YzRiMjg4YmUxY2ZhYzBlYzQ1MWRlMTNkNTIxNDgzZjljNTRhMDNkMzMzODllMDdhMjE5YmZhYjgxNzhhNDdlMjBlZGFiOTU2N2RjNWYyMmU0Y2RkZjhmNTQzYTdjMjlmYjRiZWU5YmY5MDFhYzJiOTNmZDFiZmE4NjVjM2E1NmQ5YzcyNDM2OWU4ZDc5ZGRiMDQwMjRhZDdmNzcyNjE0Mzc2MGEzMGI2MzU3NTU4NjBlNzA0MDBhMGUxNjcxNDgwNzAxNzA1MTE0Yzk4ZDlmNWVkMDlkYWVjYzA1YmM5MDA4OGM5YTllMDBhYTQ2ODJiYTQiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiZGVlNGVjMzI3NzYzNTE2YWVjZjAwNGFlMTZiZWZkNTQzMjIzYzhlM2Q0ODIwODEyMGJhYmQwZjM4YTM3MDY4ZiJ9LCJtYWMiOiJlMDlkM2FmYTAzMjI4MmQ2NzA4N2I3YWNiODRkZTM4ZDdlODMyNjY2ZDJmYmYxMDY5ODE3Y2ZiZTZmZWI0ZDc3In0sImlkIjoiYmFhZjYzMjQtYzcwNi00ZDVlLWE3ODYtZmI4OGQ2MzI0ZDVjIiwidmVyc2lvbiI6M30=" - peerId: "12D3KooWNYi2kG5cdeEUBvjemZRUkPVmAeXsSGVrX9QHnEiMfh8w" - nativeAddress: "0xa4642c066c1f8927db9d34abab599af784a2cff0" - safeAddress: "0xc5E2D5bA66916EF8413a87e3098117C6aC596597" - moduleAddress: "0x448e1116047b452CC582625a954460264D5Ad637" - hoprd-ctdapp-4: - identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiI5MmViNmE1Y2JkZTIyYTdlYTZhYjg2YzVmYmMzMzU1OCJ9LCJjaXBoZXJ0ZXh0IjoiN2IzNGU5YjY0OTFkYzQzNmE1NDRhMzUwZmVkNGIwMWZhOTFkOWZjNzk4OTYzNWVjYmZkYTJlM2U1ODIyMTlkNGY1ZDJlMTNhYWYzNTRkNGJkNjg0OGM1Yzg1N2QxMDQxNGEyNDg4ZjI4ZmM0YzYxZTM4MmU4ZGRjNjA2MjEyMTY0ZDIzMWY2NGE0YjU3MDFiM2UwMGE0OTNiMjYzMGYwYzUzZDU2Nzc0NmRhOTRlM2ZkOWNiNTUxY2VjYmY1NmIzMGJhZDkwODVjZjI5OTRhZDgyOTgyZWNhNzZmNTg4YjgzMTMxN2VjM2MxYjE5ODcwZGM1NDZkZjQ4ZjU2NDNhZTFkZTAyZmNlZmI5MWQyNGI5ZWZkOWQ5YjhmNGVlOTVhZDZlYTM2MzhjNThkYWRkODJmZTViMjk0MzFkZmMxZDdhN2M4NTY5NjJhMzc2OGNlYmMyN2FjZGYiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiYmZhMzZjMDNkZjg4ZTc2NmZlNGMyNmZmZTNmNjQ5NTFlMzRmMjdhZWU5ZmY0MjM5YTdmMDQxZTI4NzRhZTExMCJ9LCJtYWMiOiIxYjk3ZmYzN2Y3YzFkY2MxMzZkOGVjZjdiODBjZGMwNjM3NTE1M2IwOGEzYTFmYjk4YzFlNGNlMTA4YTY1ZDU4In0sImlkIjoiMzZiMDY0NTgtYzFlMC00ODg0LTk3NzctNTExYmIwMTMyOTk1IiwidmVyc2lvbiI6M30=" - peerId: "12D3KooWGyY39vD8J2VGEDjTCD3eEyvV4YrnKM9NCQa6SYJKczrR" - nativeAddress: "0xcbe8726c80cc0d7751b9545dd5a4b5b0e53e383d" - safeAddress: "0x5445A497292C8E669e7d3419BE68DE23c450c56F" - moduleAddress: "0xB32Db6FE369dF1Ee0E1E9bE78c4b488eaB361d6f" - hoprd-ctdapp-5: - identityFile: "eyJjcnlwdG8iOnsiY2lwaGVyIjoiYWVzLTEyOC1jdHIiLCJjaXBoZXJwYXJhbXMiOnsiaXYiOiI0YjcxNDJkZGUwMDA5ODhjYjI1YTJhZDRkNzRlNzIyOSJ9LCJjaXBoZXJ0ZXh0IjoiMDE1NzgxNzFkNzkwYTUwZDQ2ODQ2YTZhYzYxMjYwNjIzZmY4YzllMDIzM2JlYmFiYWZhOTliZGE2NDE1YTA2ZjhiNzc0MjE5MWRmNzdhNzRiMGIzYzc1NGE2MWU2ZGQ5Yjk0NTM2NWIxYmY5MTkyOTU0NDdjNDE3YzczNTJiODE2ZDk5ZjZlMmQyMmIxODA3MzBlNzhiNTAxYWMyM2RkYmNiZWNlZmY2NTY4NWYyOGQ4N2NkZjY2NWIwYTM2YmM2ZDZkOTI2MDRkYzUzNzJlMWY4Njg1ZWUyNmM4YjhlNDI5N2MwY2FiZWNiMDIwOTk4Y2UyZWU2NGFjODI4ZDc0OGVlNDU2ZDFiY2ZkOTZiYTI3MjAzNzg1ODQxMGRhZjRmMjI5NzIyZGY5MzkxMTEyMWNlOWVjMzliNGVlNWEzMjU5NzI1NzAwZGU0NWMwZjAxYWVjYzM4MzQiLCJrZGYiOiJzY3J5cHQiLCJrZGZwYXJhbXMiOnsiZGtsZW4iOjMyLCJuIjo4MTkyLCJwIjoxLCJyIjo4LCJzYWx0IjoiOTYxYWY0ZjM1YjliOGJhNWJlNGI0OGU3NGY1NWE1MTI0MjI0ODI2Y2M1NzY1MmExNTcyMjY5ZjBmNzg2ODY2YiJ9LCJtYWMiOiJlMzFiYmQxM2YyZWM0ZTA5ZWE2NzcxZTAzZDc5YjkwYzdhZGVjNzM1M2E0YTQzNTBlYzk3ZjU4NGM5ZDliNzgzIn0sImlkIjoiMjJjOWRlN2EtNTVhMy00YWRiLWE3ZTUtODUxOWJkNzJiZDVkIiwidmVyc2lvbiI6M30=" - peerId: "12D3KooWB1bPdu9Q5w2nzKkaCoE9gq9j8bgd3c8iVu81ypSu5WqB" - nativeAddress: "0x764d3162a4024c5cba8817446ef563b27aa57598" - safeAddress: "0x7f30E4902606291De7518f80E0863a944a80eB41" - moduleAddress: "0x221ab86f3fEF58d8e018B6c1fe5d1768925b4BEF" diff --git a/helm/values-prod.yaml b/helm/values-prod.yaml index 34082b6f..0a3ab171 100644 --- a/helm/values-prod.yaml +++ b/helm/values-prod.yaml @@ -1,5 +1,3 @@ -legacy-nodes: - enabled: true blue-nodes: enabled: true green-nodes: diff --git a/helm/values-staging.yaml b/helm/values-staging.yaml index 74ebae22..78137893 100644 --- a/helm/values-staging.yaml +++ b/helm/values-staging.yaml @@ -1,5 +1,3 @@ -legacy-nodes: - enabled: false blue-nodes: enabled: true green-nodes: From f9f708827c0fd4635a80078c13197df76228e74a Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Thu, 6 Jun 2024 11:53:52 +0200 Subject: [PATCH 20/27] Dynamic economic model parameters + env parameter input revamp (#491) --- ct-app/.envrc | 6 +- ct-app/core/__main__.py | 33 +++-- ct-app/core/components/baseclass.py | 55 +------- ct-app/core/components/decorators.py | 48 +++++-- ct-app/core/components/flags.py | 29 ---- ct-app/core/components/graphql_providers.py | 12 ++ ct-app/core/components/parameters.py | 68 ++++++++-- ct-app/core/components/utils.py | 47 ------- ct-app/core/core.py | 126 ++++++++++------- ct-app/core/model/economic_model.py | 135 ++++++++----------- ct-app/core/model/peer.py | 4 +- ct-app/core/model/subgraph_url.py | 18 ++- ct-app/core/node.py | 10 +- ct-app/core/subgraph_queries/rewards.graphql | 6 + ct-app/core/subgraph_queries/staking.graphql | 10 +- ct-app/postman/postman_tasks.py | 21 +-- ct-app/requirements.txt | 7 +- ct-app/scripts/core_prod_config.yaml | 121 +++++++++++++++++ ct-app/scripts/core_staging_config.yaml | 120 +++++++++++++++++ ct-app/test/components/test_channelstatus.py | 7 + ct-app/test/components/test_decorators.py | 73 +++++++--- ct-app/test/components/test_flags.py | 39 ------ ct-app/test/components/test_lockedvar.py | 18 +++ ct-app/test/components/test_parameters.py | 70 +++++++++- ct-app/test/components/test_utils.py | 12 +- helm/ctdapp/templates/configmap-core.yaml | 35 ----- helm/ctdapp/templates/configmap-postman.yaml | 6 +- helm/ctdapp/templates/deployment-core.yaml | 2 + helm/ctdapp/templates/secret-nodes.yaml | 2 - helm/ctdapp/templates/secret-subgraph.yaml | 7 +- helm/secrets-prod.sops.yaml | 13 +- helm/secrets-staging.sops.yaml | 13 +- helm/values-prod.yaml | 19 +-- helm/values-staging.yaml | 15 +-- 34 files changed, 727 insertions(+), 480 deletions(-) delete mode 100644 ct-app/core/components/flags.py create mode 100644 ct-app/core/subgraph_queries/rewards.graphql create mode 100644 ct-app/scripts/core_prod_config.yaml create mode 100644 ct-app/scripts/core_staging_config.yaml delete mode 100644 ct-app/test/components/test_flags.py diff --git a/ct-app/.envrc b/ct-app/.envrc index 1f5a3ee8..a320a907 100644 --- a/ct-app/.envrc +++ b/ct-app/.envrc @@ -1 +1,5 @@ - use flake \ No newline at end of file + use flake + +VIRTUAL_ENV="$PWD/.venv" +export VIRTUAL_ENV +PATH_add "$VIRTUAL_ENV/bin" \ No newline at end of file diff --git a/ct-app/core/__main__.py b/ct-app/core/__main__.py index 5df17f60..d4fceb7b 100644 --- a/ct-app/core/__main__.py +++ b/ct-app/core/__main__.py @@ -1,6 +1,8 @@ import asyncio from signal import SIGINT, SIGTERM +import click +import yaml from prometheus_client import start_http_server from .components.parameters import Parameters @@ -9,16 +11,18 @@ from .node import Node -def main(): - params = Parameters()( - "DISTRIBUTION_", - "SUBGRAPH_", - "GCP_", - "ECONOMIC_MODEL_", - "CHANNEL_", - "RABBITMQ_", - "PEER_", - ) +@click.command() +@click.option("--configfile", help="The .yaml configuration file to use") +def main(configfile: str = None): + with open(configfile, "r") as file: + config = yaml.safe_load(file) + + # import envvars to params, such as self.params.subgraph.deployer_key + params = Parameters() + params.parse(config) + params.from_env("SUBGRAPH_", "PG", "RABBITMQ_") + params.overrides("OVERRIDE_") + Utils.stringArrayToGCP( params.gcp.bucket, @@ -37,8 +41,10 @@ def main(): # start the prometheus client try: start_http_server(8080) - except OSError: - instance.error("Address already in use, prometheus client not started") + except Exception as e: + instance.error(f"Could not start the prometheus client on port 8080: {e}") + else: + instance.info("Prometheus client started on port 8080") loop = asyncio.new_event_loop() loop.add_signal_handler(SIGINT, instance.stop) @@ -54,5 +60,4 @@ def main(): if __name__ == "__main__": - if Utils.checkRequiredEnvVar("core"): - main() + main() diff --git a/ct-app/core/components/baseclass.py b/ct-app/core/components/baseclass.py index 6a97346e..ae59055a 100644 --- a/ct-app/core/components/baseclass.py +++ b/ct-app/core/components/baseclass.py @@ -9,9 +9,6 @@ class Base: """ Base class for logging and printing messages with different colors. """ - - doLogging = True - handler = logging.StreamHandler() handler.setFormatter(formatter) @@ -26,60 +23,22 @@ def print_prefix(self) -> str: @classmethod def class_prefix(cls) -> str: - return f"{cls.__name__.upper()}_" + return cls.__name__.lower() - def __format(self, message: str, color: str = "\033[0m"): + def __format(self, message: str): return f"{self.print_prefix} | {message}" - def _print(self, message: str, color: str = "\033[0m"): - print(self.__format(message, color)) - def debug(self, message: str): - """ - Log or print a debug message with the specified message. - """ - color = "\033[0;32m" - if self.doLogging: - self.logger.debug(self.__format(message, color)) - else: - self._print(message, color) + self.logger.debug(self.__format(message)) def info(self, message: str): - """ - Log or print an info message with the specified message. - """ - color = "\033[0;34m" - if self.doLogging: - self.logger.info(self.__format(message, color)) - else: - self._print(message, color) + self.logger.info(self.__format(message)) def warning(self, message: str): - """ - Log or print a warning message with the specified message. - """ - color = "\033[0;33m" - if self.doLogging: - self.logger.warning(self.__format(message, color)) - else: - self._print(message, color) + self.logger.warning(self.__format(message)) def error(self, message: str): - """ - Log or print an error message with the specified message. - """ - color = "\033[0;31m" - if self.doLogging: - self.logger.error(self.__format(message, color)) - else: - self._print(message, color) + self.logger.error(self.__format(message)) def feature(self, message: str): - """ - Log or print a feature message with the specified message. - """ - color = "\033[0;35m" - if self.doLogging: - self.logger.info(self.__format(message, color)) - else: - self._print(message, color) + self.logger.info(self.__format(message)) diff --git a/ct-app/core/components/decorators.py b/ct-app/core/components/decorators.py index aaef9fe1..e3c131d4 100644 --- a/ct-app/core/components/decorators.py +++ b/ct-app/core/components/decorators.py @@ -2,8 +2,6 @@ import functools from typing import Optional -from .flags import Flags - def connectguard(func): """ @@ -28,10 +26,26 @@ def flagguard(func): @functools.wraps(func) async def wrapper(self, *args, **kwargs): - flags = Flags.getEnvironmentFlags(self.class_prefix()) + func_name_clean = func.__name__.replace("_", "").lower() - if func.__name__ not in flags: - self.error(f"Feature `{func.__name__}` not yet available") + if not hasattr(self.params, "flags"): + self.error("No flags available") + return + + if not hasattr(self.params.flags, self.class_prefix()): + raise AttributeError(f"Feature `{func.__name__}` not in config file") + + class_flags = getattr(self.params.flags, self.class_prefix()) + + params_raw = dir(class_flags) + params_clean = list(map(lambda s: s.lower(), params_raw)) + + if func_name_clean not in params_clean: + raise AttributeError(f"Feature `{func.__name__}` not in config file") + + index = params_clean.index(func_name_clean) + if getattr(class_flags, params_raw[index]) is None: + self.error(f"Feature `{params_raw[index]}` not yet available") return return await func(self, *args, **kwargs) @@ -48,21 +62,33 @@ def formalin(message: Optional[str] = None): def decorator(func): @functools.wraps(func) async def wrapper(self, *args, **kwargs): - _delay = Flags.getEnvironmentFlagValue(func.__name__, self.class_prefix()) + func_name_clean = func.__name__.replace("_", "").lower() + class_flags = getattr(self.params.flags, self.class_prefix()) + + params_raw = dir(class_flags) + params_clean = list(map(lambda s: s.lower(), params_raw)) + + if func_name_clean not in params_clean: + self.error(f"Feature `{func.__name__}` not regonized") + return + + index = params_clean.index(func_name_clean) + delay = getattr(class_flags, params_raw[index]) - if _delay != 0: - self.debug(f"Running `{func.__name__}` every {_delay} seconds") + if delay is not None: + self.debug(f"Running `{params_raw[index]}` every {delay} seconds") while self.started: if message: self.feature(message) await func(self, *args, **kwargs) - if _delay == 0: + if delay == 0: break + + if delay is not None: + await asyncio.sleep(delay) - if _delay is not None: - await asyncio.sleep(_delay) return wrapper diff --git a/ct-app/core/components/flags.py b/ct-app/core/components/flags.py deleted file mode 100644 index 52fc930b..00000000 --- a/ct-app/core/components/flags.py +++ /dev/null @@ -1,29 +0,0 @@ -from os import environ - - -class Flags: - _cache_flags = None - global_prefix = "FLAG_" - - @classmethod - def getEnvironmentFlagValue(cls, methodname: str, prefix: str): - """ - Get the value of an environment variable starting with a given prefix. - """ - _prefix = cls.global_prefix + prefix - - return float(environ.get(f"{_prefix}{methodname.upper()}", None)) - - @classmethod - def getEnvironmentFlags(cls, prefix: str): - """ - Get all environment variable starting with a given prefix. - """ - - if cls._cache_flags is None: - cls._cache_flags = [ - key for key in environ.keys() if key.startswith(cls.global_prefix) - ] - - _prefix = cls.global_prefix + prefix - return [item.replace(_prefix, "").lower() for item in cls._cache_flags] diff --git a/ct-app/core/components/graphql_providers.py b/ct-app/core/components/graphql_providers.py index 0c99224d..dc2b2dbf 100644 --- a/ct-app/core/components/graphql_providers.py +++ b/ct-app/core/components/graphql_providers.py @@ -174,3 +174,15 @@ def __init__(self, url: str): @property def print_prefix(self) -> str: return "transaction-provider" + +class RewardsProvider(GraphQLProvider): + def __init__(self, url: str): + super().__init__(url) + self._default_key = "accounts" + self._sku_query = self._load_query( + "core/subgraph_queries/rewards.graphql" + ) + + @property + def print_prefix(self) -> str: + return "rewards-provider" \ No newline at end of file diff --git a/ct-app/core/components/parameters.py b/ct-app/core/components/parameters.py index 205d1a55..a4dbcb67 100644 --- a/ct-app/core/components/parameters.py +++ b/ct-app/core/components/parameters.py @@ -6,26 +6,62 @@ class Parameters(Base): """ Class that represents a set of parameters that can be accessed and modified. The parameters are stored in a dictionary and can be accessed and modified using the dot notation. The parameters can be loaded from environment variables with a specified prefix. """ - def __init__(self): super().__init__() - def __call__(self, *prefixes: str or list[str]): - """ - Load the parameters from the environment variables with the specified prefixes. The parameters will be stored in the instance with the name of the prefix in lowercase. If the prefix ends with an underscore, the underscore will be removed. The parameters will be stored in a new instance of the Parameters class. - - :param prefixes: The prefixes of the environment variables to load the parameters from. - """ - for prefix in prefixes: + def parse(self, data: dict): + for key, value in data.items(): subparams = type(self)() + key: str = key.replace("-", "_") + + setattr(self, key, subparams) + if isinstance(value, dict): + subparams.parse(value) + else: + setattr(self, key, value) + + def overrides(self, prefix: str): + for key, value in Utils.envvarWithPrefix(prefix).items(): + path = key.replace(prefix, "").lower().split("_") + + parent = self + + for p in path: + raw_attrs = dir(parent) + attrs = list(map(lambda str: str.lower(), raw_attrs)) + + if p.lower() in attrs: + param_name = raw_attrs[attrs.index(p)] + child = getattr(parent, param_name) + if isinstance(child, type(self)): + parent = child + else: + setattr(parent, param_name, self._convert(value)) + else: + raise KeyError(f"Key {key} not found in parameters") + + + def from_env(self, *prefixes: list[str]): + for prefix in prefixes: subparams_name = prefix.lower() if subparams_name[-1] == "_": subparams_name = subparams_name[:-1] + raw_attrs = dir(self) + attrs = list(map(lambda str: str.lower(), raw_attrs)) + if subparams_name in attrs: + subparams = getattr(self, raw_attrs[attrs.index(subparams_name)]) + else: + subparams = type(self)() + for key, value in Utils.envvarWithPrefix(prefix).items(): k = key.replace(prefix, "").lower() + # convert snake case to camel case + k = k.replace("_", " ").title().replace(" ", "") + k = k[0].lower() + k[1:] + try: value = float(value) except ValueError: @@ -42,4 +78,18 @@ def __call__(self, *prefixes: str or list[str]): setattr(self, subparams_name, subparams) - return self + def _convert(self, value: str): + try: + value = float(value) + except ValueError: + pass + + try: + integer = int(value) + if integer == value: + value = integer + + except ValueError: + pass + + return value diff --git a/ct-app/core/components/utils.py b/ct-app/core/components/utils.py index 9a72daf4..2b22ade1 100644 --- a/ct-app/core/components/utils.py +++ b/ct-app/core/components/utils.py @@ -1,5 +1,4 @@ import csv -import json import os import time from datetime import datetime, timedelta @@ -10,7 +9,6 @@ from aiohttp import ClientSession from celery import Celery from google.cloud import storage -from scripts.list_required_parameters import list_parameters from core.model.address import Address from core.model.peer import Peer @@ -36,20 +34,6 @@ def envvarWithPrefix(cls, prefix: str, type=str) -> dict[str, Any]: return dict(sorted(var_dict.items())) - @classmethod - def envvarExists(cls, var_name: str) -> bool: - return var_name in environ - - @classmethod - def checkRequiredEnvVar(cls, folder: str): - all_set_flag = True - for param in list_parameters(folder): - exists = Utils.envvarExists(param) - cls().info(f"{'✅' if exists else '❌'} {param}") - all_set_flag *= exists - - return all_set_flag - @classmethod def nodesAddresses( cls, address_prefix: str, keyenv: str @@ -171,37 +155,6 @@ def rewardProbability(cls, peers: list[Peer]) -> list[int]: return excluded - @classmethod - def jsonFromGCP(cls, bucket_name, blob_name, schema=None): - """ - Reads a JSON file and validates its contents using a schema. - :param: bucket_name: The name of the bucket - :param: blob_name: The name of the blob - ;param: schema (opt): The validation schema - :returns: (dict): The contents of the JSON file. - """ - - storage_client = storage.Client() - bucket = storage_client.bucket(bucket_name) - blob = bucket.blob(blob_name) - - with blob.open("r") as f: - contents = json.load(f) - - # if schema is not None: - # try: - # jsonschema.validate( - # contents, - # schema=schema, - # ) - # except jsonschema.ValidationError as e: - # log.exception( - # f"The file in'{blob_name}' does not follow the expected structure. {e}" - # ) - # return {} - - return contents - @classmethod def stringArrayToGCP(cls, bucket_name: str, blob_name: str, data: list[str]): """ diff --git a/ct-app/core/core.py b/ct-app/core/core.py index 45e9b412..ef076bc2 100644 --- a/ct-app/core/core.py +++ b/ct-app/core/core.py @@ -1,4 +1,5 @@ import asyncio +import random from celery import Celery from prometheus_client import Gauge @@ -10,6 +11,7 @@ SafesProvider, StakingProvider, wxHOPRTransactionProvider, + RewardsProvider ) from .components.hoprd_api import HoprdAPI from .components.lockedvar import LockedVar @@ -66,12 +68,14 @@ def __init__(self): self.registered_nodes = LockedVar("subgraph_list", list[SubgraphEntry]()) self.nft_holders = LockedVar("nft_holders", list[str]()) self.eligible_list = LockedVar("eligible_list", list[Peer]()) + self.peer_rewards = LockedVar("peer_rewards", dict[str, float]()) self.ticket_price = LockedVar("ticket_price", 1.0) # subgraphs self._safe_subgraph_url = None self._staking_subgraph_url = None self._wxhopr_txs_subgraph_url = None + # trick to have the subgraph in use displayed in the terminal self._subgraph_type = SubgraphType.NONE self.subgraph_type = SubgraphType.DEFAULT @@ -86,16 +90,17 @@ def post_init(self, nodes: list[Node], params: Parameters): node.params = params self._safe_subgraph_url = SubgraphURL( - self.params.subgraph.safes_balance_url, - self.params.subgraph.safes_balance_url_backup, + self.params.subgraph.deployerKey, self.params.subgraph.safesBalance ) self._staking_subgraph_url = SubgraphURL( - self.params.subgraph.staking_url, - self.params.subgraph.staking_url_backup, + self.params.subgraph.deployerKey, self.params.subgraph.staking ) self._wxhopr_txs_subgraph_url = SubgraphURL( - self.params.subgraph.wxhopr_txs_url, - self.params.subgraph.wxhopr_txs_url_backup, + self.params.subgraph.deployerKey, self.params.subgraph.wxHOPRTxs + ) + + self._rewards_subgraph_url = SubgraphURL( + self.params.subgraph.deployerKey, self.params.subgraph.rewards ) @property @@ -104,16 +109,12 @@ def print_prefix(self) -> str: @property def api(self) -> HoprdAPI: - return self.nodes[-1].api - - @property - def network_nodes(self) -> list[Node]: - return self.nodes[:-1] + return random.choice(self.nodes).api @property async def network_nodes_addresses(self) -> list[Address]: return await asyncio.gather( - *[node.address.get() for node in self.network_nodes] + *[node.address.get() for node in self.nodes] ) @property @@ -132,6 +133,10 @@ def staking_subgraph_url(self) -> str: def wxhopr_txs_subgraph_url(self) -> str: return self._wxhopr_txs_subgraph_url(self.subgraph_type) + @property + def rewards_subgraph_url(self) -> str: + return self._rewards_subgraph_url(self.subgraph_type) + @subgraph_type.setter def subgraph_type(self, value: SubgraphType): if value != self.subgraph_type: @@ -261,7 +266,7 @@ async def get_topology_data(self): """ channels = await self.api.all_channels(False) if channels is None: - self.warning("Topology data not available.") + self.warning("Topology data not available") return results = await Utils.aggregatePeerBalanceInChannels(channels.all) @@ -278,22 +283,21 @@ async def apply_economic_model(self): """ Applies the economic model to the eligible peers (after multiple filtering layers) and sets the eligible_list LockedVar. """ - ready: bool = False - - while not ready: - topology = await self.topology_list.get() - registered_nodes = await self.registered_nodes.get() - peers = await self.all_peers.get() - nft_holders = await self.nft_holders.get() - - self.debug(f"Topology size: {len(topology)}") - self.debug(f"Subgraph size: {len(registered_nodes)}") - self.debug(f"Network size: {len(peers)}") - self.debug(f"NFT holders: {len(nft_holders)}") - - ready = len(topology) and len(registered_nodes) and len(peers) - await asyncio.sleep(2) - + topology = await self.topology_list.get() + registered_nodes = await self.registered_nodes.get() + peers = await self.all_peers.get() + nft_holders = await self.nft_holders.get() + + self.debug(f"Topology size: {len(topology)}") + self.debug(f"Subgraph size: {len(registered_nodes)}") + self.debug(f"Network size: {len(peers)}") + self.debug(f"NFT holders: {len(nft_holders)}") + + ready = len(topology) and len(registered_nodes) and len(peers) + if not ready: + self.warning("Not enough data to apply economic model.") + return + eligibles = Utils.mergeDataSources(topology, peers, registered_nodes) self.debug(f"Merged topology and subgraph data ({len(eligibles)} entries).") @@ -302,11 +306,11 @@ async def apply_economic_model(self): old_peer_addresses = [ peer.address for peer in eligibles - if peer.version_is_old(self.params.peer.min_version) + if peer.version_is_old(self.params.peer.minVersion) ] excluded = Utils.exclude(eligibles, old_peer_addresses) self.debug( - f"Excluded peers running on old version (< {self.params.peer.min_version}) ({len(excluded)} entries)." + f"Excluded peers running on old version (< {self.params.peer.minVersion}) ({len(excluded)} entries)." ) self.debug(f"peers on wrong version: {[el.address.id for el in excluded]}") @@ -316,7 +320,7 @@ async def apply_economic_model(self): low_allowance_addresses = [ peer.address for peer in eligibles - if peer.safe_allowance < self.params.economic_model.min_safe_allowance + if peer.safe_allowance < self.params.economicModel.minSafeAllowance ] excluded = Utils.exclude(eligibles, low_allowance_addresses) self.debug(f"Excluded nodes with low safe allowance ({len(excluded)} entries).") @@ -324,27 +328,26 @@ async def apply_economic_model(self): excluded = Utils.exclude(eligibles, await self.network_nodes_addresses) self.debug(f"Excluded network nodes ({len(excluded)} entries).") - - if threshold := self.params.economic_model.nft_threshold: + + if threshold := self.params.economicModel.NFTThreshold: low_stake_non_nft_holders = [ peer.address for peer in eligibles - if peer.safe_address not in nft_holders - and peer.split_stake < threshold + if peer.safe_address not in nft_holders and peer.split_stake < threshold ] excluded = Utils.exclude(eligibles, low_stake_non_nft_holders) self.debug( f"Excluded non-nft-holders with stake < {threshold} ({len(excluded)} entries)." ) - model = EconomicModel.fromGCPFile( - self.params.gcp.bucket, self.params.economic_model.filename - ) - model.budget.ticket_price = await self.ticket_price.get() + model = EconomicModel.fromParameters(self.params.economicModel) + + redeemed_rewards = await self.peer_rewards.get() for peer in eligibles: peer.economic_model = model - peer.max_apr = self.params.distribution.max_apr_percentage + peer.economic_model.coefficients.c += redeemed_rewards.get(peer.address.address,0.0) + peer.max_apr = self.params.economicModel.maxAPRPercentage self.debug("Assigned economic model to eligible nodes.") @@ -379,7 +382,7 @@ async def distribute_rewards(self): """ model = EconomicModel.fromGCPFile( - self.params.gcp.bucket, self.params.economic_model.filename + self.params.gcp.bucket, self.params.economicModel.filename ) model.budget.ticket_price = await self.ticket_price.get() @@ -388,7 +391,7 @@ async def distribute_rewards(self): await asyncio.sleep(delay) - min_peers = self.params.distribution.min_eligible_peers + min_peers = self.params.distribution.minEligiblePeers peers = list[Peer]() @@ -401,14 +404,14 @@ async def distribute_rewards(self): # convert to csv and store on GCP filename = Utils.generateFilename( - self.params.gcp.file_prefix, self.params.gcp.folder + self.params.gcp.filePrefix, self.params.gcp.folder ) lines = Peer.toCSV(peers) Utils.stringArrayToGCP(self.params.gcp.bucket, filename, lines) # create celery tasks app = Celery( - name=self.params.rabbitmq.project_name, + name=self.params.rabbitmq.projectName, broker=f"amqp://{self.params.rabbitmq.username}:{self.params.rabbitmq.password}@{self.params.rabbitmq.host}/{self.params.rabbitmq.virtualhost}", ) app.autodiscover_tasks(force=True) @@ -419,7 +422,7 @@ async def distribute_rewards(self): peer.address.id, peer.message_count_for_reward, peer.economic_model.budget.ticket_price, - task_name=self.params.rabbitmq.task_name, + task_name=self.params.rabbitmq.taskName, ) self.info(f"Distributed rewards to {len(peers)} peers.") @@ -434,7 +437,7 @@ async def get_fundings(self): """ ct_safe_addresses = { getattr(await node.api.node_info(), "hopr_node_safe", None) - for node in self.network_nodes + for node in self.nodes } provider = wxHOPRTransactionProvider(self.wxhopr_txs_subgraph_url) @@ -453,6 +456,26 @@ async def get_fundings(self): TOTAL_FUNDING.set(total_funding) @flagguard + @formalin("Getting peers rewards amounts") + async def get_peers_rewards(self): + if self.subgraph_type == SubgraphType.NONE: + self.warning("No subgraph URL available.") + return + + provider = RewardsProvider(self.rewards_subgraph_url) + + results = dict() + try: + for account in await provider.get(): + results[account["id"]] = account["redeemedValue"] + + except ProviderError as err: + self.error(f"get_peers_rewards: {err}") + + await self.peer_rewards.set(results) + + self.debug(f"Fetched peers rewards amounts ({len(results)} entries).") + @formalin("Getting ticket price") @connectguard async def get_ticket_price(self): @@ -468,16 +491,16 @@ async def start(self): """ Start the node. """ - self.info(f"CTCore started with {len(self.network_nodes)} nodes.") + self.info(f"CTCore started with {len(self.nodes)} nodes.") - if len(self.network_nodes) == 0: + if len(self.nodes) == 0: self.error("No nodes available, exiting.") return if self.tasks: return - for node in self.network_nodes: + for node in self.nodes: node.started = True await node._retrieve_address() self.tasks.update(node.tasks()) @@ -487,6 +510,7 @@ async def start(self): self.tasks.add(asyncio.create_task(self.healthcheck())) self.tasks.add(asyncio.create_task(self.check_subgraph_urls())) self.tasks.add(asyncio.create_task(self.get_fundings())) + self.tasks.add(asyncio.create_task(self.get_peers_rewards())) self.tasks.add(asyncio.create_task(self.get_ticket_price())) self.tasks.add(asyncio.create_task(self.get_nft_holders())) @@ -505,7 +529,7 @@ def stop(self): """ self.started = False - for node in self.network_nodes: + for node in self.nodes: node.started = False for task in self.tasks: diff --git a/ct-app/core/model/economic_model.py b/ct-app/core/model/economic_model.py index 904c99c5..2175431c 100644 --- a/ct-app/core/model/economic_model.py +++ b/ct-app/core/model/economic_model.py @@ -1,12 +1,9 @@ -import os - +from core.components.parameters import Parameters from prometheus_client import Gauge -from core.components.utils import Utils - BUDGET = Gauge("budget", "Budget for the economic model") BUDGET_PERIOD = Gauge("budget_period", "Budget period for the economic model") -DISTRIBUTION_FREQUENCY = Gauge("dist_freq", "Number of expected distributions") +DISTRIBUTIONS_PER_PERIOD = Gauge("dist_freq", "Number of expected distributions") TICKET_PRICE = Gauge("ticket_price", "Ticket price") TICKET_WINNING_PROB = Gauge("ticket_winning_prob", "Ticket winning probability") @@ -17,12 +14,8 @@ def __init__(self, formula: str, condition: str): self.condition = condition @classmethod - def from_dictionary(cls, _input: dict): - formula = _input.get("formula", "") - condition = _input.get("condition", "") - - return cls(formula, condition) - + def fromParameters(cls, parameters: Parameters): + return cls(parameters.formula, parameters.condition) class Equations: def __init__(self, f_x: Equation, g_x: Equation): @@ -30,14 +23,14 @@ def __init__(self, f_x: Equation, g_x: Equation): self.g_x = g_x @classmethod - def from_dictionary(cls, _input: dict): - f_x = Equation.from_dictionary(_input.get("f_x", {})) - g_x = Equation.from_dictionary(_input.get("g_x", {})) - - return cls(f_x, g_x) + def fromParameters(cls, parameters: Parameters): + return cls( + Equation.fromParameters(parameters.fx), + Equation.fromParameters(parameters.gx), + ) -class Parameters: +class Coefficients: def __init__(self, a: float, b: float, c: float, l: float): # noqa: E741 self.a = a self.b = b @@ -45,42 +38,44 @@ def __init__(self, a: float, b: float, c: float, l: float): # noqa: E741 self.l = l @classmethod - def from_dictionary(cls, _input: dict): - a = _input.get("a", {}).get("value", None) - b = _input.get("b", {}).get("value", None) - c = _input.get("c", {}).get("value", None) - l = _input.get("l", {}).get("value", None) # noqa: E741 + def fromParameters(cls, parameters: Parameters): + return cls( + parameters.a, + parameters.b, + parameters.c, + parameters.l, + ) - return cls(a, b, c, l) - -class BudgetParameters: +class Budget: def __init__( self, - budget: float, + amount: float, period: float, s: float, - distribution_frequency: float, + distribution_per_period: float, + ticket_price: float, winning_probability: float, ): - self.budget = budget + self.amount = amount self.period = period self.s = s - self.distribution_frequency = distribution_frequency + self.distribution_per_period = distribution_per_period + self.ticket_price = ticket_price self.winning_probability = winning_probability @property - def budget(self): - return self._budget + def amount(self): + return self._amount @property def period(self): return self._period @property - def distribution_frequency(self): - return self._distribution_frequency - + def distribution_per_period(self): + return self._distribution_per_period + @property def ticket_price(self): return self._ticket_price @@ -89,9 +84,9 @@ def ticket_price(self): def winning_probability(self): return self._winning_probability - @budget.setter - def budget(self, value): - self._budget = value + @amount.setter + def amount(self, value): + self._amount = value BUDGET.set(value) @period.setter @@ -99,10 +94,10 @@ def period(self, value): self._period = value BUDGET_PERIOD.set(value) - @distribution_frequency.setter - def distribution_frequency(self, value): - self._distribution_frequency = value - DISTRIBUTION_FREQUENCY.set(value) + @distribution_per_period.setter + def distribution_per_period(self, value): + self._distribution_per_period = value + DISTRIBUTIONS_PER_PERIOD.set(value) @ticket_price.setter def ticket_price(self, value): @@ -113,38 +108,39 @@ def ticket_price(self, value): def winning_probability(self, value): self._winning_probability = value TICKET_WINNING_PROB.set(value) - + @classmethod - def from_dictionary(cls, _input: dict): - budget = _input.get("budget", {}).get("value", None) - period = _input.get("budget_period", {}).get("value", None) - s = _input.get("s", {}).get("value", None) - distribution_frequency = _input.get("dist_freq", {}).get("value", None) - winning_probability = _input.get("winning_prob", {}).get("value", None) - - return cls(budget, period, s, distribution_frequency, winning_probability) + def fromParameters(cls, parameters: Parameters): + return cls( + parameters.amount, + parameters.period, + parameters.s, + parameters.countsInPeriod, + parameters.ticketPrice, + parameters.winningProbability, + ) @property def delay_between_distributions(self): - return self.period / self.distribution_frequency + return self.period / self.distribution_per_period class EconomicModel: def __init__( - self, equations: Equations, parameters: Parameters, budget: BudgetParameters + self, equations: Equations, coefficients: Coefficients, budget: Budget ): """ Initialisation of the class. """ self.equations = equations - self.parameters = parameters + self.coefficients = coefficients self.budget = budget def transformed_stake(self, stake: float): func = self.equations.f_x # convert parameters attribute to dictionary - kwargs = vars(self.parameters) + kwargs = vars(self.coefficients) kwargs.update({"x": stake}) if not eval(func.condition, kwargs): @@ -157,27 +153,12 @@ def delay_between_distributions(self): return self.budget.delay_between_distributions @classmethod - def fromDict(cls, _input: dict): - equations = Equations.from_dictionary(_input.get("equations")) - parameters = Parameters.from_dictionary(_input.get("parameters")) - budget = BudgetParameters.from_dictionary(_input.get("budget_param")) - - return cls(equations, parameters, budget) - - @classmethod - def fromGCPFile(cls, bucket: str, filename: str): - """ - Reads parameters and equations from a JSON file and validates it using a schema. - :param: filename (str): The name of the JSON file containing the parameters - and equations. - :returns: EconomicModel: Instance containing the model parameters,equations, - budget parameters. - """ - parameters_file_path = os.path.join("assets", filename) - - contents = Utils.jsonFromGCP(bucket, parameters_file_path, None) - - return EconomicModel.fromDict(contents) - + def fromParameters(cls, parameters: Parameters): + return EconomicModel( + Equations.fromParameters(parameters.equations), + Coefficients.fromParameters(parameters.coefficients), + Budget.fromParameters(parameters.budget), + ) + def __repr__(self): - return f"EconomicModel({self.equations}, {self.parameters}, {self.budget})" + return f"EconomicModel({self.equations}, {self.coefficients}, {self.budget})" diff --git a/ct-app/core/model/peer.py b/ct-app/core/model/peer.py index 8a1cee15..5c823118 100644 --- a/ct-app/core/model/peer.py +++ b/ct-app/core/model/peer.py @@ -112,7 +112,7 @@ def max_expected_reward(self): if self.reward_probability is None: raise ValueError("Reward probability not set") - return self.reward_probability * self.economic_model.budget.budget + return self.reward_probability * self.economic_model.budget.amount @property def expected_reward(self): @@ -146,7 +146,7 @@ def protocol_reward_per_distribution(self): if self.economic_model is None: raise ValueError("Economic model not set") - return self.protocol_reward / self.economic_model.budget.distribution_frequency + return self.protocol_reward / self.economic_model.budget.distribution_per_period @property def message_count_for_reward(self): diff --git a/ct-app/core/model/subgraph_url.py b/ct-app/core/model/subgraph_url.py index 29c7968c..258c44d4 100644 --- a/ct-app/core/model/subgraph_url.py +++ b/ct-app/core/model/subgraph_url.py @@ -1,15 +1,27 @@ +from core.components.parameters import Parameters from .subgraph_type import SubgraphType class SubgraphURL: - def __init__(self, default: str, backup: str): + def __init__(self, deployer_key: str, param_set: Parameters): super().__init__() + self.param_set = param_set + self.deployer_key = deployer_key self._urls = { - SubgraphType.DEFAULT: default, - SubgraphType.BACKUP: backup, + SubgraphType.DEFAULT: self._construct_default(), + SubgraphType.BACKUP: self._construct_backup(), SubgraphType.NONE: None, } + def _construct_default(self): + if not self.param_set.queryID: + return self._construct_backup() + + return f"https://gateway.thegraph.com/api/{self.deployer_key}/subgraphs/id/{self.param_set.queryID}" + + def _construct_backup(self): + return self.param_set.URLBackup + def __call__(self, type: SubgraphType) -> str: return self._urls[type] diff --git a/ct-app/core/node.py b/ct-app/core/node.py index 419ed41c..f62ccbcf 100644 --- a/ct-app/core/node.py +++ b/ct-app/core/node.py @@ -133,7 +133,7 @@ async def retrieve_balances(self): if balances is None: self.warning("Failed to retrieve balances") return - + if addr := node_address: for token, balance in balances.items(): BALANCE.labels(addr.id, token).set(balance) @@ -163,7 +163,7 @@ async def open_channels(self): self.debug(f"Opening channel to {address}") ok = await self.api.open_channel( address, - f"{int(self.params.channel.funding_amount*1e18):d}", + f"{int(self.params.channel.fundingAmount*1e18):d}", ) if ok: self.debug(f"Opened channel to {address}") @@ -258,7 +258,7 @@ async def close_old_channels(self): if ( datetime.now() - timestamp - ).total_seconds() < self.params.channel.max_age_seconds: + ).total_seconds() < self.params.channel.maxAgeSeconds: continue channels_to_close.append(channel_id) @@ -297,7 +297,7 @@ async def fund_channels(self): low_balances = [ c for c in out_opens - if int(c.balance) / 1e18 <= self.params.channel.min_balance + if int(c.balance) / 1e18 <= self.params.channel.minBalance ] self.debug(f"Low balance channels: {len(low_balances)}") @@ -308,7 +308,7 @@ async def fund_channels(self): if channel.destination_peer_id in peer_ids: self.debug(f"Funding channel {channel.channel_id}") ok = await self.api.fund_channel( - channel.channel_id, self.params.channel.funding_amount * 1e18 + channel.channel_id, self.params.channel.fundingAmount * 1e18 ) if ok: self.debug(f"Funded channel {channel.channel_id}") diff --git a/ct-app/core/subgraph_queries/rewards.graphql b/ct-app/core/subgraph_queries/rewards.graphql new file mode 100644 index 00000000..9cee19bd --- /dev/null +++ b/ct-app/core/subgraph_queries/rewards.graphql @@ -0,0 +1,6 @@ +query ($first: Int!, $skip: Int!) { + accounts(first: $first, skip: $skip, where: {redeemedValue_gt: "0"}) { + redeemedValue + id + } +} diff --git a/ct-app/core/subgraph_queries/staking.graphql b/ct-app/core/subgraph_queries/staking.graphql index 1e34e061..a37b90e5 100644 --- a/ct-app/core/subgraph_queries/staking.graphql +++ b/ct-app/core/subgraph_queries/staking.graphql @@ -1,8 +1,8 @@ query ($first: Int!, $skip: Int!) { - boosts(first: $first, skip: $skip, where: {uri_ends_with: "Network_registry/community"}) { - id - owner { - id + boosts(first: $first, skip: $skip, where: {uri_ends_with: "Network_registry/community"}) { + id + owner { + id + } } - } } \ No newline at end of file diff --git a/ct-app/postman/postman_tasks.py b/ct-app/postman/postman_tasks.py index 8c242b54..fd1b801a 100644 --- a/ct-app/postman/postman_tasks.py +++ b/ct-app/postman/postman_tasks.py @@ -12,17 +12,22 @@ from .task_status import TaskStatus from .utils import Utils as PMUtils +import yaml log = logging.getLogger() log.setLevel(logging.INFO) -params = Parameters()("PARAM_", "RABBITMQ_") -if not Utils.checkRequiredEnvVar("postman"): - exit(1) +with open(Utils.envvar("CONFIG_FILE_PATH", type= str), "r") as file: + config = yaml.safe_load(file) + +params = Parameters() +params.parse(config) +params.from_env("PG", "RABBITMQ_") +params.overrides("OVERRIDE_") app = Celery( - name=params.rabbitmq.project_name, + name=params.rabbitmq.projectName, broker=f"amqp://{params.rabbitmq.username}:{params.rabbitmq.password}@{params.rabbitmq.host}/{params.rabbitmq.virtualhost}", ) app.autodiscover_tasks(force=True) @@ -57,7 +62,7 @@ def send_1_hop_message( attempts += 1 # send_status in [TaskStatus.SPLITTED, TaskStatus.SUCCESS] - if attempts >= params.param.max_attempts: + if attempts >= params.maxIterations: send_status = TaskStatus.TIMEOUT if send_status in [TaskStatus.RETRIED, TaskStatus.SPLIT]: @@ -133,9 +138,9 @@ async def async_send_1_hop_message( max_possible, node_peer_id, timestamp, - params.param.batch_size, - params.param.delay_between_two_messages, - params.param.message_delivery_timeout, + params.distribution.batchSize, + params.distribution.delayBetweenTwoMessages, + params.distribution.messageDeliveryDelay, ) status = TaskStatus.SPLIT if relayed < expected_count else TaskStatus.SUCCESS diff --git a/ct-app/requirements.txt b/ct-app/requirements.txt index eed7280a..387eb119 100644 --- a/ct-app/requirements.txt +++ b/ct-app/requirements.txt @@ -12,11 +12,12 @@ sqlalchemy==2.0.20 psycopg2==2.9.7 google-cloud-storage==2.10.0 black==24.3.0 -pip-chill==1.0.3 -ruff==0.3.3 +pip-chill>=1.0.3 +ruff==0.3.5 python-dotenv==1.0.1 pandas>=2.2.1 dune-client==1.7.0 openpyxl==3.1.2 dataclasses-json==0.6.4 -gql==3.5.0 \ No newline at end of file +gql==3.5.0 +pyyaml==6.0.1 \ No newline at end of file diff --git a/ct-app/scripts/core_prod_config.yaml b/ct-app/scripts/core_prod_config.yaml new file mode 100644 index 00000000..251fa039 --- /dev/null +++ b/ct-app/scripts/core_prod_config.yaml @@ -0,0 +1,121 @@ +--- +# ============================================================================= +# +# ============================================================================= +flags: + core: + healthcheck: 60 + checkSubgraphURLs: 300 + getFundings: 900 + getTicketPrice: 900 + aggregatePeers: 300 + getTopologyData: 300 + getSubgraphData: 300 + getRegisteredNodes: 300 + getNFTHolders: 900 + getPeersRewards: 900 + applyEconomicModel: 600 + distributeRewards: 1 + + + node: + healthcheck: 60 + retrievePeers: 300 + retrieveIncomingChannels: 600 + retrieveOutgoingChannels: 600 + retrieveBalances: 900 + openChannels: 300 + closeOldChannels: 300 + closePendingChannels: 1800 + fundChannels: 300 + closeIncomingChannels: ~ + getTotalChannelFunds: 900 + +# ============================================================================= +# +# ============================================================================= +economicModel: + minSafeAllowance: -1 + maxAPRPercentage: 15.0 + NFTThreshold: ~ + + coefficients: + a: 1 + b: 1.4 + c: 75000 + l: 10000 + + equations: + fx: + formula: "a * x" + condition: "l <= x <= c" + gx: + formula: "a * c + (x - c) ** (1 / b)" + condition: "x > c" + + budget: + amount: 190000 + period: 2628000 # in seconds + s: 1 + countsInPeriod: 730 + winningProbability: 1 + +# ============================================================================= +# +# ============================================================================= +distribution: + minEligiblePeers: 100 + messageDeliveryDelay: 10.0 + delayBetweenTwoMessages: 0.1 + batchSize: 200 + maxIterations: 4 + +# ============================================================================= +# +# ============================================================================= +gcp: + filePrefix: expected_reward + folder: expected_rewards + bucket: hoprnet-ctdapp-prod + +# ============================================================================= +# +# ============================================================================= +peer: + minVersion: '2.0.7' + +# ============================================================================= +# +# ============================================================================= +channel: + minBalance: 15 + fundingAmount: 35 + maxAgeSeconds: 172800 + +# ============================================================================= +# +# ============================================================================= +rabbitmq: + taskName: send_1_hop_message + projectName: ct-app + +# ============================================================================= +# +# ============================================================================= +subgraph: + safesBalance: + queryID: FEQcaX9qfh31YL2K7rxRN5a3sr9rjMWkguJnby7StNRo + URLBackup: https://api.studio.thegraph.com/query/40439/hopr-nodes-dufour/version/latest + + staking: + queryID: DrkbaCvNGVcNH1RghepLRy6NSHFi8Dmwp4T2LN3LqcjY + URLBackup: https://api.studio.thegraph.com/query/40439/hopr-stake-all-seasons/v0.0.10 + + wxHOPRTxs: + queryID: ~ + URLBackup: https://api.studio.thegraph.com/query/58438/wxhoprtransactions/v0.0.6 + + rewards: + queryID: ~ #Feg6Jero3aQzesVYuqk253NNLyNAZZppbDPKFYEGJ1Hj + URLBackup: https://api.studio.thegraph.com/query/40439/hopr-channels/version/latest +... \ No newline at end of file diff --git a/ct-app/scripts/core_staging_config.yaml b/ct-app/scripts/core_staging_config.yaml new file mode 100644 index 00000000..f2dacbb8 --- /dev/null +++ b/ct-app/scripts/core_staging_config.yaml @@ -0,0 +1,120 @@ +--- +# ============================================================================= +# +# ============================================================================= +flags: + core: + healthcheck: 10 + checkSubgraphURLs: 30 + getFundings: 30 + getTicketPrice: 30 + aggregatePeers: 30 + getTopologyData: 30 + getSubgraphData: 30 + getRegisteredNodes: 30 + getNFTHolders: 30 + getPeersRewards: 30 + applyEconomicModel: 30 + distributeRewards: ~ + + node: + healthcheck: 10 + retrievePeers: 30 + retrieveIncomingChannels: 30 + retrieveOutgoingChannels: 30 + retrieveBalances: 30 + openChannels: ~ + closeOldChannels: ~ + closePendingChannels: ~ + fundChannels: ~ + closeIncomingChannels: ~ + getTotalChannelFunds: ~ + +# ============================================================================= +# +# ============================================================================= +economicModel: + minSafeAllowance: -1 + maxAPRPercentage: 15.0 + NFTThreshold: ~ + + coefficients: + a: 1 + b: 1 + c: 3 + l: 0 + + equations: + fx: + formula: "a * x" + condition: "l <= x <= c" + gx: + formula: "a * c + (x - c) ** (1 / b)" + condition: "x > c" + + budget: + amount: 400 + period: 1200 + s: 0.25 + countsInPeriod: 1 + ticketPrice: 0.5 # deprecated + winningProbability: 1 + +# ============================================================================= +# +# ============================================================================= +distribution: + minEligiblePeers: 500 + messageDeliveryDelay: 10.0 + delayBetweenTwoMessages: 0.2 + maxIterations: 6 + +# ============================================================================= +# +# ============================================================================= +gcp: + filePrefix: expected_reward + folder: expected_rewards + bucket: hoprnet-ctdapp-staging + +# ============================================================================= +# +# ============================================================================= +peer: + minVersion: '2.0.7' + +# ============================================================================= +# +# ============================================================================= +channel: + minBalance: 0.05 + fundingAmount: 0.2 + maxAgeSeconds: 60 + +# ============================================================================= +# +# ============================================================================= +rabbitmq: + taskName: fake_task + projectName: ct-app + +# ============================================================================= +# +# ============================================================================= +subgraph: + safesBalance: + queryID: FcyLT3XGc2nEtaKjfB2SqigXsrEaGGBYsDfhEmsQ26dA + URLBackup: https://api.studio.thegraph.com/query/40439/hopr-nodes-rotsee/version/latest + + staking: + queryID: DrkbaCvNGVcNH1RghepLRy6NSHFi8Dmwp4T2LN3LqcjY + URLBackup: https://api.studio.thegraph.com/query/40439/hopr-stake-all-seasons/v0.0.10 + + wxHOPRTxs: + queryID: ~ + URLBackup: https://api.studio.thegraph.com/query/58438/wxhoprtransactions/v0.0.6 + + rewards: + queryID: ~ #Feg6Jero3aQzesVYuqk253NNLyNAZZppbDPKFYEGJ1Hj + URLBackup: https://api.studio.thegraph.com/query/40439/hopr-channels/version/latest +... \ No newline at end of file diff --git a/ct-app/test/components/test_channelstatus.py b/ct-app/test/components/test_channelstatus.py index a57b3ff7..ab016260 100644 --- a/ct-app/test/components/test_channelstatus.py +++ b/ct-app/test/components/test_channelstatus.py @@ -4,5 +4,12 @@ def test_channelstatus(): assert ChannelStatus.isPending("PendingToClose") assert not ChannelStatus.isPending("Open") + assert not ChannelStatus.isPending("Closed") + assert not ChannelStatus.isOpen("PendingToClose") assert ChannelStatus.isOpen("Open") + assert not ChannelStatus.isOpen("Closed") + + assert not ChannelStatus.isClosed("PendingToClose") + assert not ChannelStatus.isClosed("Open") + assert ChannelStatus.isClosed("Closed") diff --git a/ct-app/test/components/test_decorators.py b/ct-app/test/components/test_decorators.py index 4d92b132..1c645f8d 100644 --- a/ct-app/test/components/test_decorators.py +++ b/ct-app/test/components/test_decorators.py @@ -1,12 +1,20 @@ import asyncio -import os +from copy import deepcopy import pytest from core.components.baseclass import Base from core.components.decorators import connectguard, flagguard, formalin -from core.components.flags import Flags from core.components.lockedvar import LockedVar +from core.components.parameters import Parameters +flag_dictionary = { + "flags": { + "fooclass": { + "fooFlagguardFunc": 1, + "fooFormalinFunc": 1 + } + } +} class FooClass(Base): def __init__(self): @@ -14,6 +22,7 @@ def __init__(self): self.connected = LockedVar("connected", False) self.started = False self.counter = 0 + self.params = Parameters() @connectguard async def foo_connectguard_func(self): @@ -31,7 +40,6 @@ async def foo_formalin_func(self): self.counter += 1 await asyncio.sleep(0.1) - @pytest.fixture def foo_class(): return FooClass() @@ -54,24 +62,60 @@ async def test_flagguard(foo_class: FooClass): assert res is None # delete flag cache so that new flags are retrieved from env - Flags._cache_flags = None + foo_class.params.parse(flag_dictionary) - os.environ["FLAG_FOOCLASS_FOO_FLAGGUARD_FUNC"] = "1" res = await foo_class.foo_flagguard_func() assert res is True - del os.environ["FLAG_FOOCLASS_FOO_FLAGGUARD_FUNC"] +@pytest.mark.asyncio +async def test_flagguard_missing_flags(foo_class: FooClass): + # reset instance counter + flags = deepcopy(flag_dictionary) + # # # # # # # # # # # # # # # # # # # # + + # should not run + del flags["flags"]["fooclass"]["fooFlagguardFunc"] + + foo_class.params.parse(flags) + + with pytest.raises(AttributeError): + await foo_class.foo_flagguard_func() + + + # reset instance counter + flags = deepcopy(flag_dictionary) + foo_class.params = Parameters() + # # # # # # # # # # # # # # # # # # # # + + del flags["flags"]["fooclass"] + foo_class.params.parse(flags) + + with pytest.raises(AttributeError): + await foo_class.foo_flagguard_func() + + + # reset instance counter + flags = deepcopy(flag_dictionary) + foo_class.params = Parameters() + # # # # # # # # # # # # # # # # # # # # + + foo_class.params.parse(flag_dictionary) + foo_class.params.flags.fooclass.fooFlagguardFunc = None + + await foo_class.foo_flagguard_func() + + assert foo_class.counter == 0 # counter increased only once @pytest.mark.asyncio async def test_formalin(foo_class: FooClass): - # reset flag cache and instance counter - Flags._cache_flags = None + # reset instance counter foo_class.counter = 0 # # # # # # # # # # # # # # # # # # # # # should run only once - os.environ["FLAG_FOOCLASS_FOO_FORMALIN_FUNC"] = "0" + foo_class.params.parse(flag_dictionary) + foo_class.params.flags.fooclass.fooFormalinFunc = 0 foo_class.started = True asyncio.create_task(foo_class.foo_formalin_func()) @@ -81,15 +125,12 @@ async def test_formalin(foo_class: FooClass): assert foo_class.counter == 1 # counter increased only once - del os.environ["FLAG_FOOCLASS_FOO_FORMALIN_FUNC"] - - # reset flag cache and instance counter - Flags._cache_flags = None + # reset instance counter foo_class.counter = 0 # # # # # # # # # # # # # # # # # # # # # should run twice (every 0.5s in 1.1s) - os.environ["FLAG_FOOCLASS_FOO_FORMALIN_FUNC"] = "0.5" + foo_class.params.flags.fooclass.fooFormalinFunc = 0.5 foo_class.started = True asyncio.create_task(foo_class.foo_formalin_func()) @@ -97,6 +138,4 @@ async def test_formalin(foo_class: FooClass): foo_class.started = False await asyncio.sleep(0.5) - assert foo_class.counter == 2 # counter increased twice - - del os.environ["FLAG_FOOCLASS_FOO_FORMALIN_FUNC"] + assert foo_class.counter == 2 # counter increased twice \ No newline at end of file diff --git a/ct-app/test/components/test_flags.py b/ct-app/test/components/test_flags.py deleted file mode 100644 index 5fa84952..00000000 --- a/ct-app/test/components/test_flags.py +++ /dev/null @@ -1,39 +0,0 @@ -from core.components.flags import Flags - -import os - - -def test_getEnvironmentFlagValue(): - Flags._cache_flags = None - - os.environ["FLAG_TEST"] = "1.0" - assert Flags.getEnvironmentFlagValue("test", "") == 1.0 - del os.environ["FLAG_TEST"] - - -def test_getEnvironmentFlags(): - Flags._cache_flags = None - - os.environ["FLAG_TEST_1"] = "1.0" - os.environ["FLAG_TEST_2"] = "1.0" - os.environ["FLAG_TEST_3"] = "1.0" - - assert Flags.getEnvironmentFlags("") == ["test_1", "test_2", "test_3"] - - del os.environ["FLAG_TEST_1"] - del os.environ["FLAG_TEST_2"] - del os.environ["FLAG_TEST_3"] - - -def test_getEnvironmentFlagsWithPrefix(): - Flags._cache_flags = None - - os.environ["FLAG_FUNC_TEST_1"] = "1.0" - os.environ["FLAG_FUNC_TEST_2"] = "1.0" - os.environ["FLAG_FUNC_TEST_3"] = "1.0" - - assert Flags.getEnvironmentFlags("FUNC_") == ["test_1", "test_2", "test_3"] - - del os.environ["FLAG_FUNC_TEST_1"] - del os.environ["FLAG_FUNC_TEST_2"] - del os.environ["FLAG_FUNC_TEST_3"] diff --git a/ct-app/test/components/test_lockedvar.py b/ct-app/test/components/test_lockedvar.py index 1a079d35..f2ab4def 100644 --- a/ct-app/test/components/test_lockedvar.py +++ b/ct-app/test/components/test_lockedvar.py @@ -36,3 +36,21 @@ async def test_locker_var_infer_type(): locked_var = LockedVar("test_var", 0, infer_type=False) await locked_var.set("string") assert await locked_var.get() == "string" + +@pytest.mark.asyncio +async def test_locked_var_inc_with_infer_type(): + locked_var = LockedVar("test_var", 0, infer_type=True) + + await locked_var.inc(1.0) + + assert await locked_var.get() == 1.0 + +@pytest.mark.asyncio +async def test_locked_var_update_with_infer_type(): + locked_var = LockedVar("test_var", {}, infer_type=True) + + await locked_var.update({"key": 1.0}) + assert (await locked_var.get())["key"] == 1.0 + + with pytest.raises(TypeError): + await locked_var.update(10) \ No newline at end of file diff --git a/ct-app/test/components/test_parameters.py b/ct-app/test/components/test_parameters.py index c92e1f2e..1644ea1c 100644 --- a/ct-app/test/components/test_parameters.py +++ b/ct-app/test/components/test_parameters.py @@ -1,15 +1,61 @@ import os from core.components.parameters import Parameters +import pytest -os.environ["ENVPREFIX_STRING"] = "random-string" -os.environ["ENVPREFIX_VALUE"] = "2" -os.environ["ENVPREFIX_DECIMAL"] = "1.2" -os.environ["ENVPREFIX_URL"] = "http://localhost:8000" +params_from_yaml = { + "parent1": "value1", + "parent2": { + "child1": "value2", + "child2": { + "grandchild1": "value3" + } + } + } +def test_parse(): + params = Parameters() + params.parse(params_from_yaml) -def test_get_parameters_from_environment(): - params = Parameters()("ENVPREFIX_") + assert params.parent1 == "value1" + assert params.parent2.child1 == "value2" + assert params.parent2.child2.grandchild1 == "value3" + +def test_overrides(): + os.environ["OVERRIDES_PARENT1"] = "value1-override" + os.environ["OVERRIDES_PARENT2_CHILD1"] = "value2-override" + os.environ["OVERRIDES_PARENT2_CHILD2_GRANDCHILD1"] = "value3-override" + + params = Parameters() + params.parse(params_from_yaml) + params.overrides("OVERRIDES_") + + assert params.parent1 == "value1-override" + assert params.parent2.child1 == "value2-override" + assert params.parent2.child2.grandchild1 == "value3-override" + + del os.environ["OVERRIDES_PARENT1"] + del os.environ["OVERRIDES_PARENT2_CHILD1"] + del os.environ["OVERRIDES_PARENT2_CHILD2_GRANDCHILD1"] + +def test_overrides_raises(): + os.environ["OVERRIDES_PARENT3"] = "value1-override" + params = Parameters() + params.parse(params_from_yaml) + + with pytest.raises(KeyError): + params.overrides("OVERRIDES_") + + del os.environ["OVERRIDES_PARENT3"] + +def test_from_env(): + os.environ["ENVPREFIX_STRING"] = "random-string" + os.environ["ENVPREFIX_VALUE"] = "2" + os.environ["ENVPREFIX_DECIMAL"] = "1.2" + os.environ["ENVPREFIX_URL"] = "http://localhost:8000" + + params = Parameters() + params.from_env("ENVPREFIX") assert params.envprefix.string == os.environ.get("ENVPREFIX_STRING") assert params.envprefix.value == int(os.environ.get("ENVPREFIX_VALUE")) @@ -20,3 +66,15 @@ def test_get_parameters_from_environment(): assert isinstance(params.envprefix.value, int) assert isinstance(params.envprefix.decimal, float) assert isinstance(params.envprefix.url, str) + + del os.environ["ENVPREFIX_STRING"] + del os.environ["ENVPREFIX_VALUE"] + del os.environ["ENVPREFIX_DECIMAL"] + del os.environ["ENVPREFIX_URL"] + +def test__convert(): + params = Parameters() + + assert isinstance(params._convert("1"), int) + assert isinstance(params._convert("1.2"), float) + assert isinstance(params._convert("http://localhost:8000"), str) \ No newline at end of file diff --git a/ct-app/test/components/test_utils.py b/ct-app/test/components/test_utils.py index ba8d59f9..27536ec7 100644 --- a/ct-app/test/components/test_utils.py +++ b/ct-app/test/components/test_utils.py @@ -60,7 +60,7 @@ def test_httpPOST(): pytest.skip("Not implemented") -def test_mergeTopologyPeersSubgraph(): +def test_mergeDataSources(): pytest.skip("Not implemented") @@ -108,10 +108,6 @@ def test_rewardProbability(): pass -def test_jsonFromGCP(): - pytest.skip("Not implemented") - - def test_stringArrayToGCP(): pytest.skip("Not implemented") @@ -150,8 +146,4 @@ def test_aggregatePeerBalanceInChannels(): def test_taskSendMessage(): - pytest.skip("Not implemented") - - -def test_taskStoreFeedback(): - pytest.skip("Not implemented") + pytest.skip("Not implemented") \ No newline at end of file diff --git a/helm/ctdapp/templates/configmap-core.yaml b/helm/ctdapp/templates/configmap-core.yaml index a3c3f9cd..58a15ab0 100644 --- a/helm/ctdapp/templates/configmap-core.yaml +++ b/helm/ctdapp/templates/configmap-core.yaml @@ -5,41 +5,6 @@ metadata: argocd.argoproj.io/sync-wave: "1" name: core-config data: - FLAG_CORE_HEALTHCHECK: "60" - FLAG_CORE_CHECK_SUBGRAPH_URLS: "200" - FLAG_CORE_GET_FUNDINGS: "900" - FLAG_CORE_GET_TICKET_PRICE: "900" - FLAG_CORE_AGGREGATE_PEERS: "300" - FLAG_CORE_GET_TOPOLOGY_DATA: "300" - FLAG_CORE_GET_SUBGRAPH_DATA: "300" - FLAG_CORE_GET_REGISTERED_NODES: "300" - FLAG_CORE_GET_NFT_HOLDERS: "900" - FLAG_CORE_APPLY_ECONOMIC_MODEL: "600" - - FLAG_NODE_HEALTHCHECK: "60" - FLAG_NODE_RETRIEVE_PEERS: "300" - FLAG_NODE_RETRIEVE_OUTGOING_CHANNELS: "600" - FLAG_NODE_RETRIEVE_INCOMING_CHANNELS: "600" - FLAG_NODE_RETRIEVE_BALANCES: "900" - FLAG_NODE_OPEN_CHANNELS: "900" - FLAG_NODE_CLOSE_OLD_CHANNELS: "900" - FLAG_NODE_CLOSE_PENDING_CHANNELS: "1800" - FLAG_NODE_FUND_CHANNELS: "900" - FLAG_NODE_GET_TOTAL_CHANNEL_FUNDS: "900" - - DISTRIBUTION_MIN_ELIGIBLE_PEERS: "100" - DISTRIBUTION_MAX_APR_PERCENTAGE: "15.0" - - PEER_MIN_VERSION: "2.0.7" - - GCP_FILE_PREFIX: expected_reward - GCP_FOLDER: expected_rewards - - ECONOMIC_MODEL_MIN_SAFE_ALLOWANCE: "-1" - ECONOMIC_MODEL_NFT_THRESHOLD: "-1" - - RABBITMQ_TASK_NAME: send_1_hop_message - RABBITMQ_PROJECT_NAME: ct-app {{- if .Values.ctdapp.core.extraEnvVars -}} {{ .Values.ctdapp.core.extraEnvVars | toYaml | nindent 2 }} {{- end }} \ No newline at end of file diff --git a/helm/ctdapp/templates/configmap-postman.yaml b/helm/ctdapp/templates/configmap-postman.yaml index 3f65f378..2bfccae2 100644 --- a/helm/ctdapp/templates/configmap-postman.yaml +++ b/helm/ctdapp/templates/configmap-postman.yaml @@ -5,11 +5,7 @@ metadata: argocd.argoproj.io/sync-wave: "1" name: postman-config data: - PARAM_BATCH_SIZE: "200" - PARAM_DELAY_BETWEEN_TWO_MESSAGES: "0.2" - PARAM_MESSAGE_DELIVERY_TIMEOUT: "15" - PARAM_MAX_ATTEMPTS: "6" - RABBITMQ_PROJECT_NAME: ct-app + CONFIG_FILE_PATH: ./scripts/core_{{ .Values.environmentName }}_config.yaml {{- if .Values.ctdapp.postman.extraEnvVars -}} {{ .Values.ctdapp.postman.extraEnvVars | toYaml | nindent 2 }} {{- end }} \ No newline at end of file diff --git a/helm/ctdapp/templates/deployment-core.yaml b/helm/ctdapp/templates/deployment-core.yaml index 86fb0814..d2744968 100644 --- a/helm/ctdapp/templates/deployment-core.yaml +++ b/helm/ctdapp/templates/deployment-core.yaml @@ -49,5 +49,7 @@ spec: - python - '-m' - core + - '--configfile' + - ./scripts/core_{{ .Values.environmentName }}_config.yaml resources: {{- toYaml .Values.ctdapp.core.resources | nindent 12 }} diff --git a/helm/ctdapp/templates/secret-nodes.yaml b/helm/ctdapp/templates/secret-nodes.yaml index bf0f7d2e..2a585e89 100644 --- a/helm/ctdapp/templates/secret-nodes.yaml +++ b/helm/ctdapp/templates/secret-nodes.yaml @@ -10,5 +10,3 @@ data: NODE_KEY_3: {{ .Values.wallet.hoprdApiToken | b64enc }} NODE_KEY_4: {{ .Values.wallet.hoprdApiToken | b64enc }} NODE_KEY_5: {{ .Values.wallet.hoprdApiToken | b64enc }} - NODE_KEY_X: {{ .Values.wallet.hoprdApiToken | b64enc }} - diff --git a/helm/ctdapp/templates/secret-subgraph.yaml b/helm/ctdapp/templates/secret-subgraph.yaml index 506ebc5c..e3b5a710 100644 --- a/helm/ctdapp/templates/secret-subgraph.yaml +++ b/helm/ctdapp/templates/secret-subgraph.yaml @@ -5,9 +5,4 @@ metadata: argocd.argoproj.io/sync-wave: "1" name: subgraph data: - SUBGRAPH_STAKING_URL: {{ .Values.ctdapp.subgraph.stakingUrl | b64enc }} - SUBGRAPH_STAKING_URL_BACKUP: {{ .Values.ctdapp.subgraph.stakingUrlBackup | b64enc }} - SUBGRAPH_SAFES_BALANCE_URL: {{ .Values.ctdapp.subgraph.safesBalanceUrlBackup | b64enc }} - SUBGRAPH_SAFES_BALANCE_URL_BACKUP: {{ .Values.ctdapp.subgraph.safesBalanceUrlBackup | b64enc }} - SUBGRAPH_WXHOPR_TXS_URL: {{ .Values.ctdapp.subgraph.wxhoprTxsUrl | b64enc }} - SUBGRAPH_WXHOPR_TXS_URL_BACKUP: {{ .Values.ctdapp.subgraph.wxhoprTxsUrlBackup | b64enc }} + SUBGRAPH_DEPLOYER_KEY: {{ .Values.ctdapp.subgraph.deployerKey | b64enc }} \ No newline at end of file diff --git a/helm/secrets-prod.sops.yaml b/helm/secrets-prod.sops.yaml index 977c8c84..a3606da3 100644 --- a/helm/secrets-prod.sops.yaml +++ b/helm/secrets-prod.sops.yaml @@ -16,12 +16,7 @@ ctdapp: username: ENC[AES256_GCM,data:AE0jcxDz,iv:2mNdhHNerUpmfPSD6vCnhG4mvnB4GXl6nEWAbLdyFYc=,tag:qEt5PIu6jX1Td+BD231+0g==,type:str] virtualhost: ENC[AES256_GCM,data:243PFhLN,iv:GfcuJIy0gKK4gRxnxr3fdkophxJ9N37z1anUtHevjP0=,tag:zfEogI3z3MsMCevgbJM7zg==,type:str] subgraph: - stakingUrl: ENC[AES256_GCM,data:sBE7m5y54oTWg5oI/6VHeKnNA6tod46+eD0xqvhtG9RLXEjae5slndhA5/4FqCN5SERqOGjWfcEoehbyup0VumgtOMIdal42FcaihIFC15tMmovOrVNNcQnRWADmcqJ572TFswbLXMZp4nSphH+hulS/wP2fg35zzNqJ,iv:7Rly+ehL8uOOjdh8bXpmcQ6Iy4cLEzfu4OvbaVom9SI=,tag:Kswi4rwEs3vbFn8m82VqmQ==,type:str] - stakingUrlBackup: ENC[AES256_GCM,data:vOBU0/nBAdnBaPXXytl7qvfHSyt/7KxcnsCgSPdbGeOcurJN52iRQWGew2GjwEPB9Dh1K0I6Y/fe84sUuGpMYrFRNlMoZc9iAno=,iv:Zd3yCuidXt8ZKJJgAncG7SX3Y/6rbfUC2lb+T2ldN4Q=,tag:TCgcU2rfG2t0pQnPljj6Cg==,type:str] - safesBalanceUrl: ENC[AES256_GCM,data:1IowwCpSqbuTtPwgK2XSfOWR+WkjJupO0Xu4hB2xaxN2jeiGNbgiO+HszH3D72ECHwtxd5LKx0iXHeiJb4eCuN2MW695xXK6+/YNNHI3EfJ/D4HKr1LPEpkaI/xWjdhyv8SPscZysS7Zsed7x4xS/AwadtYxsSkcm+VB,iv:8WrNZBV98Ugp50LBbG9o8IsK3krjOApFXAEGB875c8o=,tag:GzForERisqgcffO9OxL1Jw==,type:str] - safesBalanceUrlBackup: ENC[AES256_GCM,data:SW2p9CF+0YQzTEBbpGaRYMPYhEDqg+cgXUZnCYEO24cAVn88SbGRXR+TkWEA0JAC0Pog9a76evpBMWTaMUAa00Mi24+Iok/JuiN7Aw==,iv:8t6npEO6R0HFjac05qEFvaIdGF+nTAwUPxmIz1HaNoQ=,tag:l+8foHSbz8ORnfm0be67/Q==,type:str] - wxhoprTxsUrl: ENC[AES256_GCM,data:t7mg/oC1o16tAO9y4sW2K3fvKh+1mdexjNLQinNYZ6nr6WlEPGu2xfVKHcVaGENojsfRL4uhKU/r7sOD//BbxLubVjNVDZnvw1TejyE4/KwyK9iPRouuUCDtdtAHX9X0qh8Xetbp645ahw+SPG3Y+8n0oCHLDJMTS/sa,iv:KkWhvYHN2iXSF8GeE9kG9cgR9VliB074OPLSZyEUxcY=,tag:t5OD2AbdxQjk4Ri242p07g==,type:str] - wxhoprTxsUrlBackup: ENC[AES256_GCM,data:mIttP+1Lsdevnmd1LLRLVW/rTIgsDNpmTZtHc6kz807WelJJ7jE2WImy1MnRhGYMUo0Ztl0oVJhgPGfTrREKkzOHzuIB,iv:6egK4AV8FmLhm0QGgSrfnf3uX4QTAxhFzth/1RFHtdI=,tag:7e+xTeGFBP6mBmUuB4N0zA==,type:str] + deployerKey: ENC[AES256_GCM,data:yEYJ0JoXr4nx/PKOO9C7IaPfg1/m6Kvk4KpIGDbmrmM=,iv:aGL/8ZBJ92r06iGlXVkW4zsV4uNYuDpmS4yVZwE3zoc=,tag:sx/CQzivCgvQT2IwIIId2g==,type:str] sops: kms: [] gcp_kms: [] @@ -46,8 +41,8 @@ sops: SXc0Ti85QnB6R0JNWjNoWWpIdkF3NlUKE3VUmc6OKaBcwafJ5S8jzONDI+RLh+Zx TLqa0gQAFoDmAIKtEpB/gpgPhDGjaEShQLS+OtAFUctgCS/1khG9RQ== -----END AGE ENCRYPTED FILE----- - lastmodified: "2024-05-23T13:59:03Z" - mac: ENC[AES256_GCM,data:C4PSu8of9i8koGuETHDEVbP33RUv0okgbrU/opThrPJhXTb2nlPDUhAYlrwAcfp3vGOvPQcYepEYHQcYbOzTmXjNTLuuE8xke2IfKrU2B3+fqQF4bgYKfv2EoFxHDM95qXuJkfKAoLdmLHkMPa/Wgu2d7bX89zWEUrsOy98b44s=,iv:bmq4tVBGWeJXZjMmnx3jnCKL1IOOQQUiqPWCM1bRqqI=,tag:B2BXO6k7G/j+6aqcY7wCHg==,type:str] + lastmodified: "2024-06-05T14:55:25Z" + mac: ENC[AES256_GCM,data:xjsRWVPSqFD1cn13l6Tzkg3DkBzpjwpd4C4WMaa9w6mG92BcvM8zTshtVE1gYBgdIjPbAlbsUJPaUFo2xzsW5BJxrCu/oFHo1ErwbYcYVZ2ytsTLbVaF3IhJZV9Sfn2OQPw7/NiPLAGCReYPabKAWjGE6vLP6i5iL0CV26h6w2Y=,iv:r3D4ih0RYNygh4A9jHIraLxVQI2uCVD9nu02YMpgp1o=,tag:KmEaK37fF9zRCXTOo0O2IQ==,type:str] pgp: [] unencrypted_suffix: _unencrypted - version: 3.8.0 + version: 3.8.1 diff --git a/helm/secrets-staging.sops.yaml b/helm/secrets-staging.sops.yaml index e2c7f825..c7ae1020 100644 --- a/helm/secrets-staging.sops.yaml +++ b/helm/secrets-staging.sops.yaml @@ -17,12 +17,7 @@ ctdapp: username: ENC[AES256_GCM,data:OqAIlMBH,iv:WrX+6GPjqybbUsz3m8wN4jRkqZDQWUKeDKXp/5P3eBU=,tag:7D4VryqUGpeBzTivsdJFlQ==,type:str] virtualhost: ENC[AES256_GCM,data:X7AiK8Wr,iv:p0Uo1xGlBmzWsOCrTenE3QdSFs/DJPYQ2g1Nb35hSFM=,tag:wVxKa8yM++RV2HPVs8yLpA==,type:str] subgraph: - stakingUrl: ENC[AES256_GCM,data:R3oT6qp39hbIzJzQXwrO7rU+zb96T5neQqQ+c/LMLD9qn0Cw02qU4u6KobmrzawwBOEIpRRVjOoGiFiMO8PDUwOh5xZIDnk6s0PEhR8PL74CJZNjaZDwt/S/0tty8aoB8gH3hK1Uk6f77rozya96v+0Qkbv2wnPK+nLg,iv:Gbv5ogwaWsTEBDGqTigR5QPJVI6CEIJQOwkkDeq246g=,tag:HM6ptK3hixXhMHlMNW4jOQ==,type:str] - stakingUrlBackup: ENC[AES256_GCM,data:xvqh3/VU9oXHtH6ej14+RP11Tw8wwk+QJh9b3k9vUUyPB36Ecq+sm8JKyLds36Qs/61UHlTPBwy6i+oKegvOIzShqzSZPN9safo=,iv:SX+82FWti3A0PliUUgZoaQiEjhz9MDmfoBCxgefUNX8=,tag:Ck4GT/CKq91CGT9wKewudA==,type:str] - safesBalanceUrl: ENC[AES256_GCM,data:K/dqFhJMKc8pCSiFtcrUqE+G7LEhwi65/67rfGzCiOdjl2Mo9RR4kFI/yNPvauYsycur81zOIQ/efMvlRaqfxFvfRGAOal179BLewV8KscqEVolzamfeW9g35RCtS2yTwFb2XsWTFMFZuobX07QmPr1znXtfExM8nW14,iv:T/h9G5yuL0Q4DZF0PdGpfRT/ENicaDUNDizOjDZU8Fk=,tag:xoYXlnqwHfmFKaO6fQMqgA==,type:str] - safesBalanceUrlBackup: ENC[AES256_GCM,data:t0g6/kq6CNXqL6Su9j+M0lVWqjMMHU44mdFtwVS/yY7Z7t0D77Bqr4BvCbFWBlQ1E2vkIc5iRZ/67ErrH3Ge/R/ocOS2c+NfNVDILQ==,iv:HyRmsnKXmkfyBRLOBBiyyiKuKuFmQh10hPhtxq1FnuA=,tag:vB2HygASXoY8FATgIBW+tA==,type:str] - wxhoprTxsUrl: ENC[AES256_GCM,data:Pr7W99U2r13NZFRw6haifYI38Pse/6lpe5EewSTnhmjRrzV+igrRzPAykCUOwtpqgMO95anxbj0JEeEQWdjBacCjrDuM1AU46wDUUq/ufVMs/X09FePCme8TDHLC6ke/2j5d7Vru7GZQ0LcsfUTYxio2/1ro6Qo4Kqqw,iv:zJtuDEGbizi84IlbY/b8Qk7Nc4eAmf6urODQbXU64f4=,tag:SrR8Dhzm0GWVqvjTqKNjyg==,type:str] - wxhoprTxsUrlBackup: ENC[AES256_GCM,data:l5ErOWItJN8y2ZeplUE5NqyzOMTjhqWTYJjJHGDXAobjQ3AHkGAIGWycGNyLRw0H6enHATdlAbmPLBqPtXtHmYHZLymb,iv:trt2185Yb80q41ieGvGH58npuH0fFSoBYwxVX48mCpc=,tag:VxgafnXrrTG3Cb2bT8bLGw==,type:str] + deployerKey: ENC[AES256_GCM,data:rw3RGXlzke7kSwUXwVoyEPVIifCGmdYJxxUT4m3TWvM=,iv:xUGbvnf9rGlyEBKkpfx+FAKmatGPfRohvZkgRVysqMI=,tag:w7Sl76MfMJFMYnC07TZwfg==,type:str] sops: kms: [] gcp_kms: [] @@ -47,8 +42,8 @@ sops: M1ZjcTlDVWYrbUYwQU9DUlN0NVhUY0kKyUI2VVCMfx+squtawdgIvQvgpmMeQOnd LmVJsOGerMfUsUcOv3p99jgqP2t8vsmxHx7bUe1yIUDr54LSfL/2Hw== -----END AGE ENCRYPTED FILE----- - lastmodified: "2024-05-23T13:58:09Z" - mac: ENC[AES256_GCM,data:uYAO0jsPH2b9GbWlG0FzbD/KfGytDhAhDEQZ16YhhR5KZob7Eq1TILtFo6LuZO4EMB7Bk/PZ3GQxo5+9cdzITtzpe3T9zS/NB2WCzii6Qx7FuwE+PfZVM4p9jCxGf9Hf1AFvBBwjfRU6MB3BdWiKYmV5aGq9RfEQBVf03hEQrRI=,iv:jYzrMV04E2IMZAUISB5LKPPlb4kPL2s4MAeETeTdxLc=,tag:J+LHMQ/j+WO8+cBSYnH2uQ==,type:str] + lastmodified: "2024-06-05T14:54:11Z" + mac: ENC[AES256_GCM,data:LFnwyAr3ETz0ktHs4yAKvIm1Hd9lEXOLeL7Avb121IbGuvfysWgP7I5BdKTilbn1SpqUO9SQZ4+J43CUs90MRuJM42KPQxo2QLvpHTY67f0FoBZOoJSp6ubVzqwar3gpSm4fvTp7mxkXljLKKe3Dr9pIlu0SA0aejsBbSCykzGQ=,iv:qpMzGiisIx1X8MLk8Y/siTIBHGAmYIDMXhysyE5F19c=,tag:8ObqjfbmZbHumyGhGuWQsw==,type:str] pgp: [] unencrypted_suffix: _unencrypted - version: 3.8.0 + version: 3.8.1 diff --git a/helm/values-prod.yaml b/helm/values-prod.yaml index 0a3ab171..735d69e2 100644 --- a/helm/values-prod.yaml +++ b/helm/values-prod.yaml @@ -10,28 +10,13 @@ backup: ctdapp: core: replicas: 1 - tag: v2.2.0 - extraEnvVars: - FLAG_CORE_DISTRIBUTE_REWARDS: "1" - - DISTRIBUTION_MIN_ELIGIBLE_PEERS: "100" - DISTRIBUTION_MAX_APR_PERCENTAGE: "15.0" - - GCP_BUCKET: hoprnet-ctdapp-prod - - ECONOMIC_MODEL_FILENAME: parameters-production.json - - - CHANNEL_MIN_BALANCE: "15" - CHANNEL_FUNDING_AMOUNT: "50" - CHANNEL_MAX_AGE_SECONDS: "172800" + tag: v2.2.1 postman: replicas: 1 - tag: v2.2.0 + tag: v2.2.1 nodes: NODE_ADDRESS_1: http://ctdapp-blue-node-1:3001 NODE_ADDRESS_2: http://ctdapp-blue-node-2:3001 NODE_ADDRESS_3: http://ctdapp-blue-node-3:3001 NODE_ADDRESS_4: http://ctdapp-blue-node-4:3001 NODE_ADDRESS_5: http://ctdapp-blue-node-5:3001 - NODE_ADDRESS_X: http://ctdapp-blue-node-5:3001 \ No newline at end of file diff --git a/helm/values-staging.yaml b/helm/values-staging.yaml index 78137893..7b6d1ff4 100644 --- a/helm/values-staging.yaml +++ b/helm/values-staging.yaml @@ -10,22 +10,13 @@ backup: ctdapp: core: replicas: 1 - tag: v2.2.0 - extraEnvVars: - GCP_BUCKET: hoprnet-ctdapp-staging - - ECONOMIC_MODEL_FILENAME: parameters-staging.json - - CHANNEL_MIN_BALANCE: "0.05" - CHANNEL_FUNDING_AMOUNT: "0.2" - CHANNEL_MAX_AGE_SECONDS: "172800" + tag: staging postman: replicas: 1 - tag: v2.2.0 + tag: staging nodes: NODE_ADDRESS_1: http://ctdapp-blue-node-1.ctdapp.svc:3001 NODE_ADDRESS_2: http://ctdapp-blue-node-2.ctdapp.svc:3001 NODE_ADDRESS_3: http://ctdapp-blue-node-3.ctdapp.svc:3001 NODE_ADDRESS_4: http://ctdapp-blue-node-4.ctdapp.svc:3001 - NODE_ADDRESS_5: http://ctdapp-blue-node-5.ctdapp.svc:3001 - NODE_ADDRESS_X: http://ctdapp-blue-node-5.ctdapp.svc:3001 \ No newline at end of file + NODE_ADDRESS_5: http://ctdapp-blue-node-5.ctdapp.svc:3001 \ No newline at end of file From 8c728e22632cab937e9a78b459136a8d22085bef Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Thu, 6 Jun 2024 12:01:42 +0200 Subject: [PATCH 21/27] Use local param file instead of GCP file when distributing rewards (#525) --- ct-app/core/core.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/ct-app/core/core.py b/ct-app/core/core.py index ef076bc2..de9d1e1f 100644 --- a/ct-app/core/core.py +++ b/ct-app/core/core.py @@ -381,9 +381,7 @@ async def distribute_rewards(self): Distributes the rewards to the eligible peers, based on the economic model. """ - model = EconomicModel.fromGCPFile( - self.params.gcp.bucket, self.params.economicModel.filename - ) + model = EconomicModel.fromParameters(self.params.economicModel) model.budget.ticket_price = await self.ticket_price.get() delay = Utils.nextDelayInSeconds(model.delay_between_distributions) From f9633b1753152eaafcf2634a45b483673eb92e49 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Thu, 6 Jun 2024 12:15:44 +0200 Subject: [PATCH 22/27] Fix ticket-price usage from parameters (#526) --- ct-app/core/core.py | 1 + ct-app/core/model/economic_model.py | 7 +++---- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/ct-app/core/core.py b/ct-app/core/core.py index de9d1e1f..760443d3 100644 --- a/ct-app/core/core.py +++ b/ct-app/core/core.py @@ -341,6 +341,7 @@ async def apply_economic_model(self): ) model = EconomicModel.fromParameters(self.params.economicModel) + model.budget.ticket_price = await self.ticket_price.get() redeemed_rewards = await self.peer_rewards.get() diff --git a/ct-app/core/model/economic_model.py b/ct-app/core/model/economic_model.py index 2175431c..54da3456 100644 --- a/ct-app/core/model/economic_model.py +++ b/ct-app/core/model/economic_model.py @@ -54,15 +54,14 @@ def __init__( period: float, s: float, distribution_per_period: float, - ticket_price: float, winning_probability: float, ): self.amount = amount self.period = period self.s = s self.distribution_per_period = distribution_per_period - self.ticket_price = ticket_price self.winning_probability = winning_probability + self.ticket_price = None @property def amount(self): @@ -102,7 +101,8 @@ def distribution_per_period(self, value): @ticket_price.setter def ticket_price(self, value): self._ticket_price = value - TICKET_PRICE.set(value) + if value is not None: + TICKET_PRICE.set(value) @winning_probability.setter def winning_probability(self, value): @@ -116,7 +116,6 @@ def fromParameters(cls, parameters: Parameters): parameters.period, parameters.s, parameters.countsInPeriod, - parameters.ticketPrice, parameters.winningProbability, ) From d862ee48fec916816aa94d59f76a55f31e5aa6f2 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Thu, 6 Jun 2024 12:44:02 +0200 Subject: [PATCH 23/27] Missing conversion from str to float on rewards (#527) --- ct-app/core/core.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ct-app/core/core.py b/ct-app/core/core.py index 760443d3..c61a8f87 100644 --- a/ct-app/core/core.py +++ b/ct-app/core/core.py @@ -466,7 +466,7 @@ async def get_peers_rewards(self): results = dict() try: for account in await provider.get(): - results[account["id"]] = account["redeemedValue"] + results[account["id"]] = float(account["redeemedValue"]) except ProviderError as err: self.error(f"get_peers_rewards: {err}") From 603a81cf304cd2907f929c669bf46bd20de4995c Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Thu, 6 Jun 2024 13:04:15 +0200 Subject: [PATCH 24/27] Fix economic model parameters typo (#528) --- ct-app/core/model/peer.py | 2 +- ct-app/scripts/core_prod_config.yaml | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/ct-app/core/model/peer.py b/ct-app/core/model/peer.py index 5c823118..58576119 100644 --- a/ct-app/core/model/peer.py +++ b/ct-app/core/model/peer.py @@ -103,7 +103,7 @@ def has_low_stake(self) -> bool: if self.economic_model is None: raise ValueError("Economic model not set") - return self.split_stake < self.economic_model.parameters.l + return self.split_stake < self.economic_model.coefficients.l @property def max_expected_reward(self): diff --git a/ct-app/scripts/core_prod_config.yaml b/ct-app/scripts/core_prod_config.yaml index 251fa039..47dd9e54 100644 --- a/ct-app/scripts/core_prod_config.yaml +++ b/ct-app/scripts/core_prod_config.yaml @@ -12,9 +12,9 @@ flags: getTopologyData: 300 getSubgraphData: 300 getRegisteredNodes: 300 - getNFTHolders: 900 - getPeersRewards: 900 - applyEconomicModel: 600 + getNFTHolders: 300 + getPeersRewards: 300 + applyEconomicModel: 120 distributeRewards: 1 @@ -57,7 +57,7 @@ economicModel: amount: 190000 period: 2628000 # in seconds s: 1 - countsInPeriod: 730 + countsInPeriod: 1460 winningProbability: 1 # ============================================================================= From b060e3440e02c0bca987b558693e33a149953999 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Thu, 6 Jun 2024 13:48:19 +0200 Subject: [PATCH 25/27] Fix database connection initialization using parameters (#529) --- ct-app/database/database_connection.py | 46 ++++---------------------- ct-app/postman/postman_tasks.py | 8 ++--- ct-app/postman/utils.py | 16 +++++---- 3 files changed, 19 insertions(+), 51 deletions(-) diff --git a/ct-app/database/database_connection.py b/ct-app/database/database_connection.py index 4047c2dc..3f981108 100644 --- a/ct-app/database/database_connection.py +++ b/ct-app/database/database_connection.py @@ -15,20 +15,18 @@ class DatabaseConnection: Database connection class. """ - def __init__(self): + def __init__(self, params: Parameters): """ Create a new DatabaseConnection based on environment variables setting user, password, host, port, database, sslmode, sslrootcert, sslcert and sslkey. """ - self.params = Parameters()("PG") - self._assert_parameters() url = URL( drivername="postgresql+psycopg2", - username=self.params.pg.user, - password=self.params.pg.password, - host=self.params.pg.host, - port=self.params.pg.port, - database=self.params.pg.database, + username=params.user, + password=params.password, + host=params.host, + port=params.port, + database=params.database, query={} ) @@ -38,38 +36,6 @@ def __init__(self): log.info("Database connection established.") - def _assert_parameters(self): - """ - Asserts that all required parameters are set. - """ - for group, values in self.required_parameters().items(): - assert len(getattr(self.params, group).__dict__), ( - f"Missing all '{group.upper()}' environment variables. " - + "The following ones are required: " - + f"{', '.join([(group+'(_)'+v).upper() for v in values])}" - ) - - for value in values: - assert hasattr(self.params.pg, value), ( - "Environment variable " - + f"'{group.upper()}(_){value.upper()}' missing" - ) - - @classmethod - def required_parameters(cls): - """ - Returns the required parameters for the DatabaseConnection. - """ - return { - "pg": [ - "user", - "password", - "host", - "port", - "database" - ] - } - def __enter__(self): """ Return the session (used by context manager) diff --git a/ct-app/postman/postman_tasks.py b/ct-app/postman/postman_tasks.py index fd1b801a..cd15f3bb 100644 --- a/ct-app/postman/postman_tasks.py +++ b/ct-app/postman/postman_tasks.py @@ -62,7 +62,7 @@ def send_1_hop_message( attempts += 1 # send_status in [TaskStatus.SPLITTED, TaskStatus.SUCCESS] - if attempts >= params.maxIterations: + if attempts >= params.distribution.maxIterations: send_status = TaskStatus.TIMEOUT if send_status in [TaskStatus.RETRIED, TaskStatus.SPLIT]: @@ -72,7 +72,7 @@ def send_1_hop_message( # store results in database if send_status != TaskStatus.RETRIED: - with DatabaseConnection() as session: + with DatabaseConnection(params.pg) as session: entry = Reward( peer_id=peer, node_address=node_peer_id, @@ -138,9 +138,7 @@ async def async_send_1_hop_message( max_possible, node_peer_id, timestamp, - params.distribution.batchSize, - params.distribution.delayBetweenTwoMessages, - params.distribution.messageDeliveryDelay, + params, ) status = TaskStatus.SPLIT if relayed < expected_count else TaskStatus.SUCCESS diff --git a/ct-app/postman/utils.py b/ct-app/postman/utils.py index 053d9e73..0e3937c2 100644 --- a/ct-app/postman/utils.py +++ b/ct-app/postman/utils.py @@ -1,6 +1,7 @@ import asyncio from core.components.hoprd_api import MESSAGE_TAG, HoprdAPI +from core.components.parameters import Parameters from database import DatabaseConnection, Peer @@ -16,8 +17,8 @@ def createBatches(cls, total_count: int, batch_size: int) -> list[int]: return [batch_size] * full_batches + [remainder] * bool(remainder) @classmethod - def peerIDToInt(cls, peer_id: str) -> int: - with DatabaseConnection() as session: + def peerIDToInt(cls, peer_id: str, parameters: Parameters) -> int: + with DatabaseConnection(parameters) as session: existing_peer = session.query(Peer).filter_by(peer_id=peer_id).first() if existing_peer: @@ -50,14 +51,17 @@ async def send_messages_in_batches( expected_count: int, recipient: str, timestamp: float, - batch_size: int, - delay_between_two_messages: float, - message_delivery_timeout: float, + params: Parameters, ): + + batch_size = params.distribution.batchSize, + delay_between_two_messages = params.distribution.delayBetweenTwoMessages, + message_delivery_timeout = params.distribution.messageDeliveryDelay, + relayed_count = 0 issued_count = 0 - tag = MESSAGE_TAG + cls.peerIDToInt(relayer) + tag = MESSAGE_TAG + cls.peerIDToInt(relayer, params.pg) batches = cls.createBatches(expected_count, batch_size) From 693e39be2290aa6adc34a9774c85481b33afe775 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Thu, 6 Jun 2024 14:11:12 +0200 Subject: [PATCH 26/27] Extra commas in postman task (#530) --- ct-app/postman/utils.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ct-app/postman/utils.py b/ct-app/postman/utils.py index 0e3937c2..6b1c9da2 100644 --- a/ct-app/postman/utils.py +++ b/ct-app/postman/utils.py @@ -54,9 +54,9 @@ async def send_messages_in_batches( params: Parameters, ): - batch_size = params.distribution.batchSize, - delay_between_two_messages = params.distribution.delayBetweenTwoMessages, - message_delivery_timeout = params.distribution.messageDeliveryDelay, + batch_size = params.distribution.batchSize + delay_between_two_messages = params.distribution.delayBetweenTwoMessages + message_delivery_timeout = params.distribution.messageDeliveryDelay relayed_count = 0 issued_count = 0 From 3f3e1674af1d463db794cfd7a4e92543959fb0c4 Mon Sep 17 00:00:00 2001 From: Jean Demeusy <61140535+jeandemeusy@users.noreply.github.com> Date: Thu, 6 Jun 2024 15:00:53 +0200 Subject: [PATCH 27/27] Fix peers using same upper-bound (#531) --- ct-app/core/core.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ct-app/core/core.py b/ct-app/core/core.py index c61a8f87..96d876c3 100644 --- a/ct-app/core/core.py +++ b/ct-app/core/core.py @@ -1,4 +1,5 @@ import asyncio +from copy import deepcopy import random from celery import Celery @@ -346,7 +347,7 @@ async def apply_economic_model(self): redeemed_rewards = await self.peer_rewards.get() for peer in eligibles: - peer.economic_model = model + peer.economic_model = deepcopy(model) peer.economic_model.coefficients.c += redeemed_rewards.get(peer.address.address,0.0) peer.max_apr = self.params.economicModel.maxAPRPercentage