godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/editor/debugger/editor_file_server.cpp

282 lines
11 KiB
C++
Raw Blame History

/**************************************************************************/
/* editor_file_server.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "editor_file_server.h"
#include "../editor_settings.h"
#include "core/io/marshalls.h"
#include "editor/editor_node.h"
#include "editor/export/editor_export_platform.h"
#define FILESYSTEM_PROTOCOL_VERSION 1
#define PASSWORD_LENGTH 32
#define MAX_FILE_BUFFER_SIZE 100 * 1024 * 1024 // 100mb max file buffer size (description of files to update, compressed).
static void _add_file(String f, const uint64_t &p_modified_time, HashMap<String, uint64_t> &files_to_send, HashMap<String, uint64_t> &cached_files) {
f = f.replace_first("res://", ""); // remove res://
const uint64_t *cached_mt = cached_files.getptr(f);
if (cached_mt && *cached_mt == p_modified_time) {
// File is good, skip it.
cached_files.erase(f); // Erase to mark this file as existing. Remaining files not added to files_to_send will be considered erased here, so they need to be erased in the client too.
return;
}
files_to_send.insert(f, p_modified_time);
}
void EditorFileServer::_scan_files_changed(EditorFileSystemDirectory *efd, const Vector<String> &p_tags, HashMap<String, uint64_t> &files_to_send, HashMap<String, uint64_t> &cached_files) {
for (int i = 0; i < efd->get_file_count(); i++) {
String f = efd->get_file_path(i);
if (FileAccess::exists(f + ".import")) {
// is imported, determine what to do
// Todo the modified times of remapped files should most likely be kept in EditorFileSystem to speed this up in the future.
Ref<ConfigFile> cf;
cf.instantiate();
Error err = cf->load(f + ".import");
ERR_CONTINUE(err != OK);
{
uint64_t mt = FileAccess::get_modified_time(f + ".import");
_add_file(f + ".import", mt, files_to_send, cached_files);
}
if (!cf->has_section("remap")) {
continue;
}
List<String> remaps;
cf->get_section_keys("remap", &remaps);
for (const String &remap : remaps) {
if (remap == "path") {
String remapped_path = cf->get_value("remap", remap);
uint64_t mt = FileAccess::get_modified_time(remapped_path);
_add_file(remapped_path, mt, files_to_send, cached_files);
} else if (remap.begins_with("path.")) {
String feature = remap.get_slice(".", 1);
if (p_tags.find(feature) != -1) {
String remapped_path = cf->get_value("remap", remap);
uint64_t mt = FileAccess::get_modified_time(remapped_path);
_add_file(remapped_path, mt, files_to_send, cached_files);
}
}
}
} else {
uint64_t mt = efd->get_file_modified_time(i);
_add_file(f, mt, files_to_send, cached_files);
}
}
for (int i = 0; i < efd->get_subdir_count(); i++) {
_scan_files_changed(efd->get_subdir(i), p_tags, files_to_send, cached_files);
}
}
static void _add_custom_file(const String &f, HashMap<String, uint64_t> &files_to_send, HashMap<String, uint64_t> &cached_files) {
if (!FileAccess::exists(f)) {
return;
}
_add_file(f, FileAccess::get_modified_time(f), files_to_send, cached_files);
}
void EditorFileServer::poll() {
if (!active) {
return;
}
if (!server->is_connection_available()) {
return;
}
Ref<StreamPeerTCP> tcp_peer = server->take_connection();
ERR_FAIL_COND(tcp_peer.is_null());
// Got a connection!
EditorProgress pr("updating_remote_file_system", TTR("Updating assets on target device:"), 105);
pr.step(TTR("Syncing headers"), 0, true);
print_verbose("EFS: Connecting taken!");
char header[4];
Error err = tcp_peer->get_data((uint8_t *)&header, 4);
ERR_FAIL_COND(err != OK);
ERR_FAIL_COND(header[0] != 'G');
ERR_FAIL_COND(header[1] != 'R');
ERR_FAIL_COND(header[2] != 'F');
ERR_FAIL_COND(header[3] != 'S');
uint32_t protocol_version = tcp_peer->get_u32();
ERR_FAIL_COND(protocol_version != FILESYSTEM_PROTOCOL_VERSION);
char cpassword[PASSWORD_LENGTH + 1];
err = tcp_peer->get_data((uint8_t *)cpassword, PASSWORD_LENGTH);
cpassword[PASSWORD_LENGTH] = 0;
ERR_FAIL_COND(err != OK);
print_verbose("EFS: Got password: " + String(cpassword));
ERR_FAIL_COND_MSG(password != cpassword, "Client disconnected because password mismatch.");
uint32_t tag_count = tcp_peer->get_u32();
print_verbose("EFS: Getting tags: " + itos(tag_count));
ERR_FAIL_COND(tcp_peer->get_status() != StreamPeerTCP::STATUS_CONNECTED);
Vector<String> tags;
for (uint32_t i = 0; i < tag_count; i++) {
String tag = tcp_peer->get_utf8_string();
print_verbose("EFS: tag #" + itos(i) + ": " + tag);
ERR_FAIL_COND(tcp_peer->get_status() != StreamPeerTCP::STATUS_CONNECTED);
tags.push_back(tag);
}
uint32_t file_buffer_decompressed_size = tcp_peer->get_32();
HashMap<String, uint64_t> cached_files;
if (file_buffer_decompressed_size > 0) {
pr.step(TTR("Getting remote file system"), 1, true);
// Got files cached by client.
uint32_t file_buffer_size = tcp_peer->get_32();
print_verbose("EFS: Getting file buffer: compressed - " + String::humanize_size(file_buffer_size) + " decompressed: " + String::humanize_size(file_buffer_decompressed_size));
ERR_FAIL_COND(tcp_peer->get_status() != StreamPeerTCP::STATUS_CONNECTED);
ERR_FAIL_COND(file_buffer_size > MAX_FILE_BUFFER_SIZE);
LocalVector<uint8_t> file_buffer;
file_buffer.resize(file_buffer_size);
LocalVector<uint8_t> file_buffer_decompressed;
file_buffer_decompressed.resize(file_buffer_decompressed_size);
err = tcp_peer->get_data(file_buffer.ptr(), file_buffer_size);
pr.step(TTR("Decompressing remote file system"), 2, true);
ERR_FAIL_COND(err != OK);
// Decompress the text with all the files
Compression::decompress(file_buffer_decompressed.ptr(), file_buffer_decompressed.size(), file_buffer.ptr(), file_buffer.size(), Compression::MODE_ZSTD);
String files_text = String::utf8((const char *)file_buffer_decompressed.ptr(), file_buffer_decompressed.size());
Vector<String> files = files_text.split("\n");
print_verbose("EFS: Total cached files received: " + itos(files.size()));
for (int i = 0; i < files.size(); i++) {
if (files[i].get_slice_count("::") != 2) {
continue;
}
String file = files[i].get_slice("::", 0);
uint64_t modified_time = files[i].get_slice("::", 1).to_int();
cached_files.insert(file, modified_time);
}
} else {
// Client does not have any files stored.
}
pr.step(TTR("Scanning for local changes"), 3, true);
print_verbose("EFS: Scanning changes:");
HashMap<String, uint64_t> files_to_send;
// Scan files to send.
_scan_files_changed(EditorFileSystem::get_singleton()->get_filesystem(), tags, files_to_send, cached_files);
// Add forced export files
Vector<String> forced_export = EditorExportPlatform::get_forced_export_files();
for (int i = 0; i < forced_export.size(); i++) {
_add_custom_file(forced_export[i], files_to_send, cached_files);
}
_add_custom_file("res://project.godot", files_to_send, cached_files);
// Check which files were removed and also add them
for (KeyValue<String, uint64_t> K : cached_files) {
if (!files_to_send.has(K.key)) {
files_to_send.insert(K.key, 0); //0 means removed
}
}
tcp_peer->put_32(files_to_send.size());
print_verbose("EFS: Sending list of changed files.");
pr.step(TTR("Sending list of changed files:"), 4, true);
// Send list of changed files first, to ensure that if connecting breaks, the client is not found in a broken state.
for (KeyValue<String, uint64_t> K : files_to_send) {
tcp_peer->put_utf8_string(K.key);
tcp_peer->put_64(K.value);
}
print_verbose("EFS: Sending " + itos(files_to_send.size()) + " files.");
int idx = 0;
for (KeyValue<String, uint64_t> K : files_to_send) {
pr.step(TTR("Sending file:") + " " + K.key.get_file(), 5 + idx * 100 / files_to_send.size(), false);
idx++;
if (K.value == 0 || !FileAccess::exists("res://" + K.key)) { // File was removed
continue;
}
Vector<uint8_t> array = FileAccess::_get_file_as_bytes("res://" + K.key);
tcp_peer->put_64(array.size());
tcp_peer->put_data(array.ptr(), array.size());
ERR_FAIL_COND(tcp_peer->get_status() != StreamPeerTCP::STATUS_CONNECTED);
}
tcp_peer->put_data((const uint8_t *)"GEND", 4); // End marker.
print_verbose("EFS: Done.");
}
void EditorFileServer::start() {
if (active) {
stop();
}
port = EDITOR_GET("filesystem/file_server/port");
password = EDITOR_GET("filesystem/file_server/password");
Error err = server->listen(port);
ERR_FAIL_COND_MSG(err != OK, "EditorFileServer: Unable to listen on port " + itos(port));
active = true;
}
bool EditorFileServer::is_active() const {
return active;
}
void EditorFileServer::stop() {
if (active) {
server->stop();
active = false;
}
}
EditorFileServer::EditorFileServer() {
server.instantiate();
EDITOR_DEF("filesystem/file_server/port", 6010);
EDITOR_DEF("filesystem/file_server/password", "");
}
EditorFileServer::~EditorFileServer() {
stop();
}
Reference in New Issue View Git Blame Copy Permalink