diff --git a/code b/code new file mode 100644 index 000000000..2a071fb30 --- /dev/null +++ b/code @@ -0,0 +1,690 @@ +{ + "id": 4228, + "value": { + "serverInfo": { + "arch": "x86_64", + "platform": "x86_64", + "id": "81260ce3-b6f2-471e-a77e-0250c11fb907", + "hostname": "tasty-mahogany", + "version": "0.3.6-alpha.7", + "lastBackup": null, + "lanAddress": "https://tasty-mahogany.local/", + "postInitMigrationTodos": [], + "torAddress": "https://4iqvmnjyqlqiq2nfavk7emhyjwhq6s454oubur4givisxblfdwxfj6ad.onion/", + "onionAddress": "4iqvmnjyqlqiq2nfavk7emhyjwhq6s454oubur4givisxblfdwxfj6ad", + "ipInfo": { + "enp8s0": { + "ipv4Range": "192.168.122.86/24", + "ipv6Range": null, + "ipv4": "192.168.122.86", + "ipv6": null + } + }, + "statusInfo": { + "backupProgress": null, + "updated": false, + "updateProgress": null, + "shuttingDown": false, + "restarting": false + }, + "wifi": { + "ssids": [], + "selected": null, + "interface": null, + "lastRegion": null + }, + "unreadNotificationCount": 0, + "passwordHash": "$argon2id$v=19$m=65536,t=3,p=1$qZNXS7Xk+qeOfi7ZO18OpA$VHr96ABySCvi/fa5p+N+SY8XJ/FyhxVp3LlBxmxQa6Y", + "pubkey": "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIM1ThH4SGEGzCFoKlkmMw3tNXvx975xXKEn/dNnBDEGb", + "caFingerprint": "88:CF:91:19:FC:35:18:E8:B1:8E:B1:36:53:B2:22:6A:EA:5B:58:E6:35:7A:A5:82:1B:39:1:D5:E4:F8:57:3C", + "ntpSynced": true, + "zram": true, + "governor": null, + "smtp": null, + "devices": [ + { + "class": "processor", + "product": "AMD Ryzen 9 5950X 16-Core Processor" + }, + { + "class": "processor", + "product": "AMD Ryzen 9 5950X 16-Core Processor" + }, + { + "class": "processor", + "product": "AMD Ryzen 9 5950X 16-Core Processor" + }, + { + "class": "processor", + "product": "AMD Ryzen 9 5950X 16-Core Processor" + }, + { + "class": "processor", + "product": "AMD Ryzen 9 5950X 16-Core Processor" + }, + { + "class": "processor", + "product": "AMD Ryzen 9 5950X 16-Core Processor" + }, + { + "class": "display", + "product": "Virtio 1.0 GPU" + } + ], + "packageVersionCompat": ">=0.3.0:0 <=0.3.6-alpha.7:0", + "ram": 10285481984 + }, + "packageData": { + "vaultwarden": { + "stateInfo": { + "state": "installed", + "manifest": { + "id": "vaultwarden", + "title": "Vaultwarden", + "version": "1.32.1:0", + "satisfies": [], + "releaseNotes": "* Updated to the latest upstream code with notable changes:\n - Fixed syncing and login issues with native mobile clients\n* Full change log available [here](https://github.com/dani-garcia/vaultwarden/releases/tag/1.32.1)", + "canMigrateTo": "!", + "canMigrateFrom": "*", + "license": "AGPLv3", + "wrapperRepo": "https://github.com/Start9Labs/vaultwarden-startos", + "upstreamRepo": "https://github.com/dani-garcia/vaultwarden", + "supportSite": "https://vaultwarden.discourse.group/", + "marketingSite": "https://github.com/dani-garcia/vaultwarden/", + "donationUrl": "https://www.paypal.com/paypalme/DaniGG", + "description": { + "short": "Secure password management", + "long": "Vaultwarden is a lightweight and secure password manager for storing and auto-filling sensitive information such as usernames and passwords, credit cards, identities, and notes. It is an alternative implementation of the Bitwarden server API written in Rust and compatible with upstream Bitwarden clients. All data is stored in an encrypted vault on your server." + }, + "images": { + "main": { + "source": "packed", + "arch": [ + "aarch64", + "x86_64" + ], + "emulateMissingAs": null + } + }, + "assets": [], + "volumes": [ + "main" + ], + "alerts": { + "install": null, + "uninstall": null, + "restore": null, + "start": null, + "stop": null + }, + "dependencies": {}, + "hardwareRequirements": { + "device": [], + "ram": null, + "arch": [ + "aarch64", + "x86_64" + ] + }, + "gitHash": "74a504429097e933285782e1e4c425da5895d516\n", + "osVersion": "0.3.5.1" + } + }, + "dataVersion": null, + "status": { + "main": "error", + "debug": "Error { source: \n 0: \u001b[91minvalid type: map, expected a sequence at line 1 column 1353\u001b[0m\n\nLocation:\n \u001b[35m/home/rust/src/core/models/src/errors.rs\u001b[0m:\u001b[35m509\u001b[0m\n\n ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ SPANTRACE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n 0: \u001b[91mstartos::s9pk::v2\u001b[0m\u001b[91m::\u001b[0m\u001b[91mdeserialize\u001b[0m\n at \u001b[35mstartos/src/s9pk/v2/mod.rs\u001b[0m:\u001b[35m265\u001b[0m\n 1: \u001b[91mstartos::service\u001b[0m\u001b[91m::\u001b[0m\u001b[91mload\u001b[0m\n at \u001b[35mstartos/src/service/mod.rs\u001b[0m:\u001b[35m271\u001b[0m\n 2: \u001b[91mstartos::service::service_map\u001b[0m\u001b[91m::\u001b[0m\u001b[91mload\u001b[0m\n at \u001b[35mstartos/src/service/service_map.rs\u001b[0m:\u001b[35m80\u001b[0m\n\nBacktrace omitted. Run with RUST_BACKTRACE=1 environment variable to display it.\nRun with RUST_BACKTRACE=full to include source snippets., kind: Deserialization, revision: None }", + "message": "Deserialization Error: invalid type: map, expected a sequence at line 1 column 1353", + "onRebuild": "start" + }, + "registry": null, + "developerKey": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAIwXjctXTc37QTXRYWxLxElY1r2NhoKJRrl604Nu/0l4=\n-----END PUBLIC KEY-----\n", + "icon": "data:image/png;base64,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", + "lastBackup": null, + "currentDependencies": {}, + "actions": { + "config": { + "name": "Configure", + "description": "Customize Vaultwarden", + "warning": null, + "visibility": "enabled", + "allowedStatuses": "any", + "hasInput": true, + "group": null + }, + "properties": { + "name": "Properties", + "description": "Runtime information, credentials, and other values of interest", + "warning": null, + "visibility": "enabled", + "allowedStatuses": "any", + "hasInput": false, + "group": null + } + }, + "requestedActions": {}, + "serviceInterfaces": { + "main-8080": { + "id": "main-8080", + "name": "Web Interface/Bitwarden Protocol", + "description": "Main user interface for interacting with Vaultwarden in a web browser. Also serves the bitwarden protocol.", + "hasPrimary": false, + "masked": false, + "addressInfo": { + "username": null, + "hostId": "main", + "internalPort": 8080, + "scheme": "http", + "sslScheme": "https", + "suffix": "" + }, + "type": "ui" + } + }, + "hosts": { + "main": { + "kind": "multi", + "bindings": { + "8080": { + "enabled": false, + "options": { + "preferredExternalPort": 80, + "addSsl": { + "preferredExternalPort": 443, + "alpn": { + "specified": [ + "http/1.1" + ] + } + }, + "secure": null + }, + "lan": { + "assignedPort": null, + "assignedSslPort": 49152 + } + }, + "3443": { + "enabled": false, + "options": { + "preferredExternalPort": 443, + "addSsl": null, + "secure": null + }, + "lan": { + "assignedPort": null, + "assignedSslPort": null + } + } + }, + "addresses": [ + { + "kind": "onion", + "address": "mibog33n4dzldkve2uqm2muqkhrbnibkpu22rms6qrrhylwssuv7h2ad" + } + ], + "hostnameInfo": {} + } + }, + "storeExposedDependents": [] + }, + "bitcoind": { + "stateInfo": { + "state": "installed", + "manifest": { + "id": "bitcoind", + "title": "Bitcoin Core", + "version": "27.1.0:0", + "satisfies": [], + "releaseNotes": "* Update Bitcoin to [v27.1](https://github.com/bitcoin/bitcoin/releases/tag/v27.1)\n* Add 'Reindex Chainstate' Action\n* Improve config descriptions and instructions\n* Notice! If Bitcoin gets stuck in \"Stopping\" status after the update, the solution is to restart your server. System -> Restart.\n", + "canMigrateTo": "!", + "canMigrateFrom": "*", + "license": "MIT", + "wrapperRepo": "https://github.com/Start9Labs/bitcoind-startos", + "upstreamRepo": "https://github.com/bitcoin/bitcoin", + "supportSite": "https://github.com/bitcoin/bitcoin/issues", + "marketingSite": "https://bitcoincore.org/", + "donationUrl": null, + "description": { + "short": "A Bitcoin Full Node by Bitcoin Core", + "long": "Bitcoin is an innovative payment network and a new kind of money. Bitcoin uses peer-to-peer technology to operate with no central authority or banks; managing transactions and the issuing of bitcoins is carried out collectively by the network. Bitcoin is open-source; its design is public, nobody owns or controls Bitcoin and everyone can take part. Through many of its unique properties, Bitcoin allows exciting uses that could not be covered by any previous payment system." + }, + "images": { + "compat": { + "source": "packed", + "arch": [ + "aarch64", + "x86_64" + ], + "emulateMissingAs": null + }, + "main": { + "source": "packed", + "arch": [ + "aarch64", + "x86_64" + ], + "emulateMissingAs": null + } + }, + "assets": [ + "compat" + ], + "volumes": [ + "main" + ], + "alerts": { + "install": null, + "uninstall": "Uninstalling Bitcoin Core will result in permanent loss of data. Without a backup, any funds stored on your node's default hot wallet will be lost forever. If you are unsure, we recommend making a backup, just to be safe.", + "restore": "Restoring Bitcoin Core will overwrite its current data. You will lose any transactions recorded in watch-only wallets, and any funds you have received to the hot wallet, since the last backup.", + "start": null, + "stop": null + }, + "dependencies": {}, + "hardwareRequirements": { + "device": [], + "ram": null, + "arch": null + }, + "gitHash": "c995ed1b85f79135fde30a0c056fdb4ee465b50d\n", + "osVersion": "0.3.4.4" + } + }, + "dataVersion": null, + "status": { + "main": "error", + "debug": "Error { source: \n 0: \u001b[91minvalid type: map, expected a sequence at line 1 column 1985\u001b[0m\n\nLocation:\n \u001b[35m/home/rust/src/core/models/src/errors.rs\u001b[0m:\u001b[35m509\u001b[0m\n\n ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ SPANTRACE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n 0: \u001b[91mstartos::s9pk::v2\u001b[0m\u001b[91m::\u001b[0m\u001b[91mdeserialize\u001b[0m\n at \u001b[35mstartos/src/s9pk/v2/mod.rs\u001b[0m:\u001b[35m265\u001b[0m\n 1: \u001b[91mstartos::service\u001b[0m\u001b[91m::\u001b[0m\u001b[91mload\u001b[0m\n at \u001b[35mstartos/src/service/mod.rs\u001b[0m:\u001b[35m271\u001b[0m\n 2: \u001b[91mstartos::service::service_map\u001b[0m\u001b[91m::\u001b[0m\u001b[91mload\u001b[0m\n at \u001b[35mstartos/src/service/service_map.rs\u001b[0m:\u001b[35m80\u001b[0m\n\nBacktrace omitted. Run with RUST_BACKTRACE=1 environment variable to display it.\nRun with RUST_BACKTRACE=full to include source snippets., kind: Deserialization, revision: None }", + "message": "Deserialization Error: invalid type: map, expected a sequence at line 1 column 1985", + "onRebuild": "start" + }, + "registry": null, + "developerKey": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAIwXjctXTc37QTXRYWxLxElY1r2NhoKJRrl604Nu/0l4=\n-----END PUBLIC KEY-----\n", + "icon": "data:image/png;base64,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", + "lastBackup": null, + "currentDependencies": {}, + "actions": { + "delete-coinstatsindex": { + "name": "Delete Coinstats Index", + "description": "Deletes the Coinstats Index (coinstatsindex) in case it gets corrupted.", + "warning": "The Coinstats Index will be rebuilt once Bitcoin Core is started again, unless you deactivate it in the config settings. Please don't do this unless instructed to by Start9 support staff.", + "visibility": "enabled", + "allowedStatuses": "only-stopped", + "hasInput": true, + "group": null + }, + "delete-peers": { + "name": "Delete Peer List", + "description": "Deletes the Peer List (peers.dat) in case it gets corrupted.", + "warning": null, + "visibility": "enabled", + "allowedStatuses": "only-stopped", + "hasInput": true, + "group": null + }, + "delete-txindex": { + "name": "Delete Transaction Index", + "description": "Deletes the Transaction Index (txindex) in case it gets corrupted.", + "warning": "The Transaction Index will be rebuilt once Bitcoin Core is started again, unless you deactivate it in the config settings. Please don't do this unless instructed to by Start9 support staff.", + "visibility": "enabled", + "allowedStatuses": "only-stopped", + "hasInput": true, + "group": null + }, + "reindex": { + "name": "Reindex Blockchain", + "description": "Rebuilds the block and chainstate databases starting from genesis. If blocks already exist on disk, these are used rather than being redownloaded. For pruned nodes, this means downloading the entire blockchain over again.", + "warning": "Blocks not stored on disk will be redownloaded in order to rebuild the database. If your node is pruned, this action is equivalent to syncing the node from scratch, so this process could take weeks on low-end hardware.", + "visibility": "enabled", + "allowedStatuses": "any", + "hasInput": true, + "group": null + }, + "reindex-chainstate": { + "name": "Reindex Chainstate", + "description": "Rebuilds the chainstate database using existing block index data; as the block index is not rebuilt, 'reindex_chainstate' should be strictly faster than 'reindex'. This action should only be used in the case of chainstate corruption; if the blocks stored on disk are corrupted, the 'reindex' action will need to be run instead.", + "warning": "While faster than 'Reindex', 'Reindex Chainstate' can still take several days or more to complete. Pruned nodes do not allow 'reindex-chainstate'; if you are running a pruned node and suspect chainstate corruption the 'reindex' action (requiring redownloading the entire Blockchain) should be run instead.", + "visibility": "enabled", + "allowedStatuses": "any", + "hasInput": true, + "group": null + }, + "config": { + "name": "Configure", + "description": "Customize Bitcoin Core", + "warning": null, + "visibility": "enabled", + "allowedStatuses": "any", + "hasInput": true, + "group": null + }, + "properties": { + "name": "Properties", + "description": "Runtime information, credentials, and other values of interest", + "warning": null, + "visibility": "enabled", + "allowedStatuses": "any", + "hasInput": false, + "group": null + } + }, + "requestedActions": {}, + "serviceInterfaces": { + "peer-8333": { + "id": "peer-8333", + "name": "Peer Interface", + "description": "Listens for incoming connections from peers on the bitcoin network", + "hasPrimary": false, + "masked": false, + "addressInfo": { + "username": null, + "hostId": "peer", + "internalPort": 8333, + "scheme": null, + "sslScheme": null, + "suffix": "" + }, + "type": "api" + }, + "rpc-8332": { + "id": "rpc-8332", + "name": "RPC Interface", + "description": "Listens for JSON-RPC commands", + "hasPrimary": false, + "masked": false, + "addressInfo": { + "username": null, + "hostId": "rpc", + "internalPort": 8332, + "scheme": "http", + "sslScheme": "https", + "suffix": "" + }, + "type": "api" + }, + "zmq-28332": { + "id": "zmq-28332", + "name": "ZeroMQ Interface", + "description": "Listens for subscriptions to the ZeroMQ raw block and raw transaction event streams", + "hasPrimary": false, + "masked": false, + "addressInfo": { + "username": null, + "hostId": "zmq", + "internalPort": 28332, + "scheme": null, + "sslScheme": null, + "suffix": "" + }, + "type": "api" + } + }, + "hosts": { + "peer": { + "kind": "multi", + "bindings": { + "8333": { + "enabled": false, + "options": { + "preferredExternalPort": 8333, + "addSsl": null, + "secure": null + }, + "lan": { + "assignedPort": null, + "assignedSslPort": null + } + } + }, + "addresses": [ + { + "kind": "onion", + "address": "m27eb66v4tndzhowirshkysxt6rmt6iubmjxxc2l2leca7lphcbs7sid" + } + ], + "hostnameInfo": {} + }, + "rpc": { + "kind": "multi", + "bindings": { + "8332": { + "enabled": false, + "options": { + "preferredExternalPort": 8332, + "addSsl": { + "preferredExternalPort": 443, + "alpn": { + "specified": [ + "http/1.1" + ] + } + }, + "secure": null + }, + "lan": { + "assignedPort": null, + "assignedSslPort": 49153 + } + } + }, + "addresses": [ + { + "kind": "onion", + "address": "4dc6awce5nc4ldc36b4naibuzzsj5dwgyfvp43uc3mjp2nnvprchniyd" + } + ], + "hostnameInfo": {} + }, + "zmq": { + "kind": "multi", + "bindings": { + "28332": { + "enabled": false, + "options": { + "preferredExternalPort": 28332, + "addSsl": null, + "secure": null + }, + "lan": { + "assignedPort": null, + "assignedSslPort": null + } + }, + "28333": { + "enabled": false, + "options": { + "preferredExternalPort": 28333, + "addSsl": null, + "secure": null + }, + "lan": { + "assignedPort": null, + "assignedSslPort": null + } + } + }, + "addresses": [ + { + "kind": "onion", + "address": "dmdx34vr7mpjgtmxuhj67vmec7xvh7omxaxyunqpg35dvcbs4pvdh7id" + } + ], + "hostnameInfo": {} + } + }, + "storeExposedDependents": [] + }, + "hello-world": { + "stateInfo": { + "state": "installed", + "manifest": { + "id": "hello-world", + "title": "Hello World", + "version": "0.3.6:0", + "satisfies": [], + "releaseNotes": "Revamped for StartOS 0.3.6", + "canMigrateTo": "=0.3.6:0", + "canMigrateFrom": "=0.3.6:0 || <0.3.6:0", + "license": "mit", + "wrapperRepo": "https://github.com/Start9Labs/hello-world-wrapper", + "upstreamRepo": "https://github.com/Start9Labs/hello-world", + "supportSite": "https://docs.start9.com/", + "marketingSite": "https://start9.com/", + "donationUrl": "https://donate.start9.com/", + "description": { + "short": "Bare bones example of a StartOS service", + "long": "Hello World is a template service that provides examples of basic StartOS features." + }, + "images": { + "main": { + "source": "packed", + "arch": [ + "aarch64", + "x86_64" + ], + "emulateMissingAs": "aarch64" + } + }, + "assets": [], + "volumes": [ + "main" + ], + "alerts": { + "install": "Optional alert to display before installing the service", + "uninstall": null, + "restore": null, + "start": null, + "stop": null + }, + "dependencies": {}, + "hardwareRequirements": { + "device": [], + "ram": null, + "arch": null + }, + "gitHash": null, + "osVersion": "0.3.6" + } + }, + "dataVersion": "0.3.6:0", + "status": { + "main": "error", + "debug": "Error { source: \n 0: \u001b[91minvalid type: map, expected a sequence at line 1 column 922\u001b[0m\n\nLocation:\n \u001b[35m/home/rust/src/core/models/src/errors.rs\u001b[0m:\u001b[35m509\u001b[0m\n\n ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ SPANTRACE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n 0: \u001b[91mstartos::s9pk::v2\u001b[0m\u001b[91m::\u001b[0m\u001b[91mdeserialize\u001b[0m\n at \u001b[35mstartos/src/s9pk/v2/mod.rs\u001b[0m:\u001b[35m265\u001b[0m\n 1: \u001b[91mstartos::service\u001b[0m\u001b[91m::\u001b[0m\u001b[91mload\u001b[0m\n at \u001b[35mstartos/src/service/mod.rs\u001b[0m:\u001b[35m271\u001b[0m\n 2: \u001b[91mstartos::service::service_map\u001b[0m\u001b[91m::\u001b[0m\u001b[91mload\u001b[0m\n at \u001b[35mstartos/src/service/service_map.rs\u001b[0m:\u001b[35m80\u001b[0m\n 3: \u001b[91mstartos::service::service_map\u001b[0m\u001b[91m::\u001b[0m\u001b[91minit\u001b[0m\n at \u001b[35mstartos/src/service/service_map.rs\u001b[0m:\u001b[35m60\u001b[0m\n 4: \u001b[91mstartos::context::rpc\u001b[0m\u001b[91m::\u001b[0m\u001b[91mcleanup_and_initialize\u001b[0m\n at \u001b[35mstartos/src/context/rpc.rs\u001b[0m:\u001b[35m300\u001b[0m\n 5: \u001b[91mstartos::context::rpc\u001b[0m\u001b[91m::\u001b[0m\u001b[91minit\u001b[0m\n at \u001b[35mstartos/src/context/rpc.rs\u001b[0m:\u001b[35m118\u001b[0m\n 6: \u001b[91mstartos::bins::start_init\u001b[0m\u001b[91m::\u001b[0m\u001b[91msetup_or_init\u001b[0m\n at \u001b[35mstartos/src/bins/start_init.rs\u001b[0m:\u001b[35m21\u001b[0m\n 7: \u001b[91mstartos::bins::start_init\u001b[0m\u001b[91m::\u001b[0m\u001b[91mmain\u001b[0m\n at \u001b[35mstartos/src/bins/start_init.rs\u001b[0m:\u001b[35m204\u001b[0m\n 8: \u001b[91mstartos::bins::startd\u001b[0m\u001b[91m::\u001b[0m\u001b[91minner_main\u001b[0m\n at \u001b[35mstartos/src/bins/startd.rs\u001b[0m:\u001b[35m21\u001b[0m\n\nBacktrace omitted. Run with RUST_BACKTRACE=1 environment variable to display it.\nRun with RUST_BACKTRACE=full to include source snippets., kind: Deserialization, revision: None }", + "message": "Deserialization Error: invalid type: map, expected a sequence at line 1 column 922", + "onRebuild": "start" + }, + "registry": null, + "developerKey": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAhUw/T99KgSZQYh1mp1FzDaZCOLmSG9qYSMNjw5WCfP4=\n-----END PUBLIC KEY-----\n", + "icon": "data:image/png;base64,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", + "lastBackup": null, + "currentDependencies": {}, + "actions": { + "set-name": { + "name": "Set Name", + "description": "Set your name so Hello World can say hello to you", + "warning": null, + "visibility": "enabled", + "allowedStatuses": "any", + "hasInput": true, + "group": null + }, + "show-secret-phrase": { + "name": "Show Secret Phrase", + "description": "Reveal the secret phrase for Hello World", + "warning": null, + "visibility": "enabled", + "allowedStatuses": "any", + "hasInput": false, + "group": null + }, + "name-to-logs": { + "name": "Print name to Logs", + "description": "Prints \"Hello [Name]\" to the service logs.", + "warning": null, + "visibility": "enabled", + "allowedStatuses": "only-running", + "hasInput": false, + "group": null + } + }, + "requestedActions": {}, + "serviceInterfaces": { + "ui": { + "id": "ui", + "name": "Web UI", + "description": "The web interface of Hello World", + "hasPrimary": false, + "masked": false, + "addressInfo": { + "username": null, + "hostId": "ui-multi", + "internalPort": 80, + "scheme": "http", + "sslScheme": "https", + "suffix": "" + }, + "type": "ui" + } + }, + "hosts": { + "ui-multi": { + "kind": "multi", + "bindings": { + "80": { + "enabled": false, + "options": { + "preferredExternalPort": 80, + "addSsl": { + "preferredExternalPort": 443, + "alpn": { + "specified": [ + "http/1.1" + ] + } + }, + "secure": null + }, + "lan": { + "assignedPort": null, + "assignedSslPort": 49154 + } + } + }, + "addresses": [ + { + "kind": "onion", + "address": "b5vx4e3liq2twdeuqqp5bcuvqvoh2hil3yyci7re4ioeiwz4q3qlg2qd" + } + ], + "hostnameInfo": {} + } + }, + "storeExposedDependents": [] + } + }, + "ui": { + "name": null, + "ack-welcome": "0.3.5.1", + "marketplace": { + "selected-url": "https://registry.start9.com/", + "known-hosts": { + "https://registry.start9.com/": { + "name": "Start9 Registry" + }, + "https://community-registry.start9.com/": { + "name": "Community Registry" + } + } + }, + "dev": {}, + "gaming": { + "snake": { + "high-score": 0 + } + }, + "ack-instructions": {}, + "theme": "Dark", + "widgets": [], + "ackWelcome": "0.3.6-alpha.7" + } + } +} diff --git a/core/startos/src/s9pk/v2/mod.rs b/core/startos/src/s9pk/v2/mod.rs index e012480af..7a94c0d79 100644 --- a/core/startos/src/s9pk/v2/mod.rs +++ b/core/startos/src/s9pk/v2/mod.rs @@ -102,6 +102,19 @@ impl S9pk { }) } + pub fn new_with_manifest( + archive: MerkleArchive, + size: Option, + manifest: Manifest, + ) -> Self { + Self { + manifest, + manifest_dirty: true, + archive, + size, + } + } + pub fn validate_and_filter(&mut self, arch: Option<&str>) -> Result<(), Error> { let filter = self.manifest.validate_for(arch, self.archive.contents())?; filter.keep_checked(self.archive.contents_mut()) @@ -263,10 +276,10 @@ impl> + FileSource + Clone> S9pk { impl S9pk> { #[instrument(skip_all)] - pub async fn deserialize( + pub async fn archive( source: &S, commitment: Option<&MerkleArchiveCommitment>, - ) -> Result { + ) -> Result>, Error> { use tokio::io::AsyncReadExt; let mut header = source @@ -283,9 +296,14 @@ impl S9pk> { ErrorKind::ParseS9pk, "Invalid Magic or Unexpected Version" ); - - let mut archive = - MerkleArchive::deserialize(source, SIG_CONTEXT, &mut header, commitment).await?; + MerkleArchive::deserialize(source, SIG_CONTEXT, &mut header, commitment).await + } + #[instrument(skip_all)] + pub async fn deserialize( + source: &S, + commitment: Option<&MerkleArchiveCommitment>, + ) -> Result { + let mut archive = Self::archive(source, commitment).await?; archive.sort_by(|a, b| match (priority(a), priority(b)) { (Some(a), Some(b)) => a.cmp(&b), diff --git a/core/startos/src/version/mod.rs b/core/startos/src/version/mod.rs index 10a02d63b..f71cec8b3 100644 --- a/core/startos/src/version/mod.rs +++ b/core/startos/src/version/mod.rs @@ -26,8 +26,9 @@ mod v0_3_6_alpha_4; mod v0_3_6_alpha_5; mod v0_3_6_alpha_6; mod v0_3_6_alpha_7; +mod v0_3_6_alpha_8; -pub type Current = v0_3_6_alpha_7::Version; // VERSION_BUMP +pub type Current = v0_3_6_alpha_8::Version; // VERSION_BUMP impl Current { #[instrument(skip(self, db))] @@ -104,6 +105,7 @@ enum Version { V0_3_6_alpha_5(Wrapper), V0_3_6_alpha_6(Wrapper), V0_3_6_alpha_7(Wrapper), + V0_3_6_alpha_8(Wrapper), Other(exver::Version), } @@ -135,6 +137,7 @@ impl Version { Self::V0_3_6_alpha_5(v) => DynVersion(Box::new(v.0)), Self::V0_3_6_alpha_6(v) => DynVersion(Box::new(v.0)), Self::V0_3_6_alpha_7(v) => DynVersion(Box::new(v.0)), + Self::V0_3_6_alpha_8(v) => DynVersion(Box::new(v.0)), Self::Other(v) => { return Err(Error::new( eyre!("unknown version {v}"), @@ -158,6 +161,7 @@ impl Version { Version::V0_3_6_alpha_5(Wrapper(x)) => x.semver(), Version::V0_3_6_alpha_6(Wrapper(x)) => x.semver(), Version::V0_3_6_alpha_7(Wrapper(x)) => x.semver(), + Version::V0_3_6_alpha_8(Wrapper(x)) => x.semver(), Version::Other(x) => x.clone(), } } diff --git a/core/startos/src/version/v0_3_6_alpha_8.rs b/core/startos/src/version/v0_3_6_alpha_8.rs new file mode 100644 index 000000000..b23c205e8 --- /dev/null +++ b/core/startos/src/version/v0_3_6_alpha_8.rs @@ -0,0 +1,125 @@ +use exver::{PreReleaseSegment, VersionRange}; +use tokio::fs::File; + +use super::v0_3_5::V0_3_0_COMPAT; +use super::{v0_3_6_alpha_7, VersionT}; +use crate::s9pk::manifest::{DeviceFilter, Manifest}; +use crate::s9pk::merkle_archive::MerkleArchive; +use crate::s9pk::v2::SIG_CONTEXT; +use crate::s9pk::S9pk; +use crate::util::io::create_file; +use crate::{ + install::PKG_ARCHIVE_DIR, s9pk::merkle_archive::source::multi_cursor_file::MultiCursorFile, +}; +use crate::{prelude::*, service::LoadDisposition}; + +lazy_static::lazy_static! { + static ref V0_3_6_alpha_8: exver::Version = exver::Version::new( + [0, 3, 6], + [PreReleaseSegment::String("alpha".into()), 8.into()] + ); +} + +#[derive(Clone, Copy, Debug, Default)] +pub struct Version; + +impl VersionT for Version { + type Previous = v0_3_6_alpha_7::Version; + type PreUpRes = (); + + async fn pre_up(self) -> Result { + Ok(()) + } + fn semver(self) -> exver::Version { + V0_3_6_alpha_8.clone() + } + fn compat(self) -> &'static VersionRange { + &V0_3_0_COMPAT + } + fn up(self, _: &mut Value, _: Self::PreUpRes) -> Result<(), Error> { + Ok(()) + } + async fn post_up(self, ctx: &crate::context::RpcContext) -> Result<(), Error> { + let s9pk_dir = ctx.datadir.join(PKG_ARCHIVE_DIR).join("installed"); + + for s9pk_path in s9pk_dir.read_dir()? { + let s9pk_path = s9pk_path?.path(); + let matches_s9pk = s9pk_path.extension().map(|x| x == "s9pk").unwrap_or(false); + if !matches_s9pk { + continue; + } + + let get_archive = async { + let multi_cursor = MultiCursorFile::from(File::open(&s9pk_path).await?); + Ok::<_, Error>(S9pk::archive(&multi_cursor, None).await?) + }; + + let archive: MerkleArchive< + crate::s9pk::merkle_archive::source::Section, + > = match get_archive.await { + Ok(a) => a, + Err(e) => { + tracing::error!("Error opening s9pk for install: {e}"); + tracing::debug!("{e:?}"); + continue; + } + }; + + let previous_manifest: Value = serde_json::from_slice::( + &archive + .contents() + .get_path("manifest.json") + .or_not_found("manifest.json")? + .read_file_to_vec() + .await?, + ) + .with_kind(ErrorKind::Deserialization)? + .into(); + + let mut manifest = previous_manifest.clone(); + + if let Some(device) = previous_manifest["hardwareRequirements"]["device"].as_object() { + manifest["hardwareRequirements"]["device"] = to_value( + &device + .into_iter() + .map(|(class, product)| { + Ok::<_, Error>(DeviceFilter { + pattern_description: format!( + "a {class} device matching the expression {}", + &product + ), + class: class.clone(), + pattern: from_value(product.clone())?, + }) + }) + .fold(Ok::<_, Error>(Vec::new()), |acc, value| { + let mut acc = acc?; + acc.push(value?); + Ok(acc) + })?, + )?; + } + + if previous_manifest != manifest { + let tmp_path = s9pk_path.with_extension("s9pk.tmp"); + let mut tmp_file = create_file(&tmp_path).await?; + // TODO, wouldn't this break in the later versions of the manifest that would need changes, this doesn't seem to be a good way to handle this + let manifest: Manifest = from_value(manifest.clone())?; + let id = manifest.id.clone(); + let mut s9pk: S9pk<_> = S9pk::new_with_manifest(archive, None, manifest); + let s9pk_compat_key = ctx.account.read().await.compat_s9pk_key.clone(); + s9pk.as_archive_mut() + .set_signer(s9pk_compat_key, SIG_CONTEXT); + s9pk.serialize(&mut tmp_file, true).await?; + tmp_file.sync_all().await?; + tokio::fs::rename(&tmp_path, &s9pk_path).await?; + ctx.services.load(ctx, &id, LoadDisposition::Retry).await?; + } + } + + Ok(()) + } + fn down(self, _db: &mut Value) -> Result<(), Error> { + Ok(()) + } +}