mirror of
https://github.com/godotengine/godot.git
synced 2025-10-31 21:51:22 +00:00
0f7af4ea51
-Changed SectionedPropertyEditor to support this -Renamed Globals singleton to GlobalConfig, makes more sense. -Changed the logic behind persisten global settings, instead of the persist checkbox, a revert button is now available
575 lines
13 KiB
C++
575 lines
13 KiB
C++
/*************************************************************************/
|
|
/* file_access_network.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2017 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 "file_access_network.h"
|
|
#include "marshalls.h"
|
|
#include "globals.h"
|
|
#include "os/os.h"
|
|
#include "io/ip.h"
|
|
|
|
|
|
|
|
//#define DEBUG_PRINT(m_p) print_line(m_p)
|
|
//#define DEBUG_TIME(m_what) printf("MS: %s - %lli\n",m_what,OS::get_singleton()->get_ticks_usec());
|
|
#define DEBUG_PRINT(m_p)
|
|
#define DEBUG_TIME(m_what)
|
|
|
|
|
|
void FileAccessNetworkClient::lock_mutex() {
|
|
|
|
mutex->lock();
|
|
lockcount++;
|
|
}
|
|
|
|
void FileAccessNetworkClient::unlock_mutex() {
|
|
|
|
lockcount--;
|
|
mutex->unlock();
|
|
|
|
}
|
|
|
|
void FileAccessNetworkClient::put_32(int p_32) {
|
|
|
|
uint8_t buf[4];
|
|
encode_uint32(p_32,buf);
|
|
client->put_data(buf,4);
|
|
DEBUG_PRINT("put32: "+itos(p_32));
|
|
}
|
|
|
|
void FileAccessNetworkClient::put_64(int64_t p_64) {
|
|
|
|
uint8_t buf[8];
|
|
encode_uint64(p_64,buf);
|
|
client->put_data(buf,8);
|
|
DEBUG_PRINT("put64: "+itos(p_64));
|
|
|
|
}
|
|
|
|
int FileAccessNetworkClient::get_32() {
|
|
|
|
uint8_t buf[4];
|
|
client->get_data(buf,4);
|
|
return decode_uint32(buf);
|
|
|
|
}
|
|
|
|
int64_t FileAccessNetworkClient::get_64() {
|
|
|
|
uint8_t buf[8];
|
|
client->get_data(buf,8);
|
|
return decode_uint64(buf);
|
|
|
|
}
|
|
|
|
void FileAccessNetworkClient::_thread_func() {
|
|
|
|
client->set_nodelay(true);
|
|
while(!quit) {
|
|
|
|
DEBUG_PRINT("SEM WAIT - "+itos(sem->get()));
|
|
Error err = sem->wait();
|
|
DEBUG_TIME("sem_unlock");
|
|
//DEBUG_PRINT("semwait returned "+itos(werr));
|
|
DEBUG_PRINT("MUTEX LOCK "+itos(lockcount));
|
|
DEBUG_PRINT("POPO");
|
|
DEBUG_PRINT("PEPE");
|
|
lock_mutex();
|
|
DEBUG_PRINT("MUTEX PASS");
|
|
|
|
blockrequest_mutex->lock();
|
|
while(block_requests.size()) {
|
|
put_32(block_requests.front()->get().id);
|
|
put_32(FileAccessNetwork::COMMAND_READ_BLOCK);
|
|
put_64(block_requests.front()->get().offset);
|
|
put_32(block_requests.front()->get().size);
|
|
block_requests.pop_front();
|
|
}
|
|
blockrequest_mutex->unlock();
|
|
|
|
DEBUG_PRINT("THREAD ITER");
|
|
|
|
DEBUG_TIME("sem_read");
|
|
int id = get_32();
|
|
|
|
int response = get_32();
|
|
DEBUG_PRINT("GET RESPONSE: "+itos(response));
|
|
|
|
FileAccessNetwork *fa=NULL;
|
|
|
|
if (response!=FileAccessNetwork::RESPONSE_DATA) {
|
|
ERR_FAIL_COND(!accesses.has(id));
|
|
}
|
|
|
|
if (accesses.has(id))
|
|
fa=accesses[id];
|
|
|
|
|
|
switch(response) {
|
|
|
|
case FileAccessNetwork::RESPONSE_OPEN: {
|
|
|
|
|
|
DEBUG_TIME("sem_open");
|
|
int status = get_32();
|
|
if (status!=OK) {
|
|
fa->_respond(0,Error(status));
|
|
} else {
|
|
uint64_t len = get_64();
|
|
fa->_respond(len,Error(status));
|
|
}
|
|
|
|
fa->sem->post();
|
|
|
|
|
|
} break;
|
|
case FileAccessNetwork::RESPONSE_DATA: {
|
|
|
|
int64_t offset = get_64();
|
|
uint32_t len = get_32();
|
|
|
|
Vector<uint8_t> block;
|
|
block.resize(len);
|
|
client->get_data(block.ptr(),len);
|
|
|
|
if (fa) //may have been queued
|
|
fa->_set_block(offset,block);
|
|
|
|
} break;
|
|
case FileAccessNetwork::RESPONSE_FILE_EXISTS: {
|
|
|
|
|
|
int status = get_32();
|
|
fa->exists_modtime=status!=0;
|
|
fa->sem->post();
|
|
|
|
|
|
|
|
} break;
|
|
case FileAccessNetwork::RESPONSE_GET_MODTIME: {
|
|
|
|
|
|
uint64_t status = get_64();
|
|
fa->exists_modtime=status;
|
|
fa->sem->post();
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
|
|
unlock_mutex();
|
|
}
|
|
|
|
}
|
|
|
|
void FileAccessNetworkClient::_thread_func(void *s) {
|
|
|
|
FileAccessNetworkClient *self =(FileAccessNetworkClient*)s;
|
|
|
|
self->_thread_func();
|
|
|
|
}
|
|
|
|
Error FileAccessNetworkClient::connect(const String& p_host,int p_port,const String& p_password) {
|
|
|
|
IP_Address ip;
|
|
|
|
if (p_host.is_valid_ip_address()) {
|
|
ip=p_host;
|
|
} else {
|
|
ip=IP::get_singleton()->resolve_hostname(p_host);
|
|
}
|
|
|
|
DEBUG_PRINT("IP: "+String(ip)+" port "+itos(p_port));
|
|
Error err = client->connect(ip,p_port);
|
|
ERR_FAIL_COND_V(err,err);
|
|
while(client->get_status()==StreamPeerTCP::STATUS_CONNECTING) {
|
|
//DEBUG_PRINT("trying to connect....");
|
|
OS::get_singleton()->delay_usec(1000);
|
|
}
|
|
|
|
if (client->get_status()!=StreamPeerTCP::STATUS_CONNECTED) {
|
|
return ERR_CANT_CONNECT;
|
|
}
|
|
|
|
CharString cs = p_password.utf8();
|
|
put_32(cs.length());
|
|
client->put_data((const uint8_t*)cs.ptr(),cs.length());
|
|
|
|
int e = get_32();
|
|
|
|
if (e!=OK) {
|
|
return ERR_INVALID_PARAMETER;
|
|
}
|
|
|
|
thread = Thread::create(_thread_func,this);
|
|
|
|
return OK;
|
|
}
|
|
|
|
FileAccessNetworkClient *FileAccessNetworkClient::singleton=NULL;
|
|
|
|
|
|
FileAccessNetworkClient::FileAccessNetworkClient() {
|
|
|
|
thread=NULL;
|
|
mutex = Mutex::create();
|
|
blockrequest_mutex = Mutex::create();
|
|
quit=false;
|
|
singleton=this;
|
|
last_id=0;
|
|
client = Ref<StreamPeerTCP>( StreamPeerTCP::create_ref() );
|
|
sem=Semaphore::create();
|
|
lockcount=0;
|
|
}
|
|
|
|
FileAccessNetworkClient::~FileAccessNetworkClient() {
|
|
|
|
if (thread) {
|
|
quit=true;
|
|
sem->post();
|
|
Thread::wait_to_finish(thread);
|
|
memdelete(thread);
|
|
}
|
|
|
|
memdelete(blockrequest_mutex);
|
|
memdelete(mutex);
|
|
memdelete(sem);
|
|
|
|
|
|
}
|
|
|
|
void FileAccessNetwork::_set_block(size_t p_offset,const Vector<uint8_t>& p_block) {
|
|
|
|
|
|
int page = p_offset/page_size;
|
|
ERR_FAIL_INDEX(page,pages.size());
|
|
if (page<pages.size()-1) {
|
|
ERR_FAIL_COND(p_block.size()!=page_size);
|
|
} else {
|
|
ERR_FAIL_COND( (p_block.size() != (total_size%page_size)));
|
|
}
|
|
|
|
buffer_mutex->lock();
|
|
pages[page].buffer=p_block;
|
|
pages[page].queued=false;
|
|
buffer_mutex->unlock();
|
|
|
|
if (waiting_on_page==page) {
|
|
waiting_on_page=-1;
|
|
page_sem->post();
|
|
}
|
|
}
|
|
|
|
|
|
void FileAccessNetwork::_respond(size_t p_len,Error p_status) {
|
|
|
|
DEBUG_PRINT("GOT RESPONSE - len: "+itos(p_len)+" status: "+itos(p_status));
|
|
response=p_status;
|
|
if (response!=OK)
|
|
return;
|
|
opened=true;
|
|
total_size=p_len;
|
|
int pc = ((total_size-1)/page_size)+1;
|
|
pages.resize(pc);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
Error FileAccessNetwork::_open(const String& p_path, int p_mode_flags) {
|
|
|
|
ERR_FAIL_COND_V(p_mode_flags!=READ,ERR_UNAVAILABLE);
|
|
if (opened)
|
|
close();
|
|
FileAccessNetworkClient *nc = FileAccessNetworkClient::singleton;
|
|
DEBUG_PRINT("open: "+p_path);
|
|
|
|
DEBUG_TIME("open_begin");
|
|
|
|
nc->lock_mutex();
|
|
nc->put_32(id);
|
|
nc->accesses[id]=this;
|
|
nc->put_32(COMMAND_OPEN_FILE);
|
|
CharString cs =p_path.utf8();
|
|
nc->put_32(cs.length());
|
|
nc->client->put_data((const uint8_t*)cs.ptr(),cs.length());
|
|
pos=0;
|
|
eof_flag=false;
|
|
last_page=-1;
|
|
last_page_buff=NULL;
|
|
|
|
// buffers.clear();
|
|
nc->unlock_mutex();
|
|
DEBUG_PRINT("OPEN POST");
|
|
DEBUG_TIME("open_post");
|
|
nc->sem->post(); //awaiting answer
|
|
DEBUG_PRINT("WAIT...");
|
|
sem->wait();
|
|
DEBUG_TIME("open_end");
|
|
DEBUG_PRINT("WAIT ENDED...");
|
|
|
|
return response;
|
|
}
|
|
|
|
void FileAccessNetwork::close(){
|
|
|
|
if (!opened)
|
|
return;
|
|
|
|
FileAccessNetworkClient *nc = FileAccessNetworkClient::singleton;
|
|
|
|
DEBUG_PRINT("CLOSE");
|
|
nc->lock_mutex();
|
|
nc->put_32(id);
|
|
nc->put_32(COMMAND_CLOSE);
|
|
pages.clear();
|
|
opened=false;
|
|
nc->unlock_mutex();
|
|
|
|
|
|
}
|
|
bool FileAccessNetwork::is_open() const{
|
|
|
|
return opened;
|
|
}
|
|
|
|
void FileAccessNetwork::seek(size_t p_position){
|
|
|
|
ERR_FAIL_COND(!opened);
|
|
eof_flag=p_position>total_size;
|
|
|
|
if (p_position>=total_size) {
|
|
p_position=total_size;
|
|
}
|
|
|
|
pos=p_position;
|
|
}
|
|
|
|
void FileAccessNetwork::seek_end(int64_t p_position){
|
|
|
|
seek(total_size+p_position);
|
|
|
|
}
|
|
size_t FileAccessNetwork::get_pos() const{
|
|
|
|
ERR_FAIL_COND_V(!opened,0);
|
|
return pos;
|
|
}
|
|
size_t FileAccessNetwork::get_len() const{
|
|
|
|
ERR_FAIL_COND_V(!opened,0);
|
|
return total_size;
|
|
}
|
|
|
|
bool FileAccessNetwork::eof_reached() const{
|
|
|
|
ERR_FAIL_COND_V(!opened,false);
|
|
return eof_flag;
|
|
}
|
|
|
|
uint8_t FileAccessNetwork::get_8() const{
|
|
|
|
uint8_t v;
|
|
get_buffer(&v,1);
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
void FileAccessNetwork::_queue_page(int p_page) const {
|
|
|
|
if (p_page>=pages.size())
|
|
return;
|
|
if (pages[p_page].buffer.empty() && !pages[p_page].queued) {
|
|
|
|
|
|
FileAccessNetworkClient *nc = FileAccessNetworkClient::singleton;
|
|
|
|
nc->blockrequest_mutex->lock();
|
|
FileAccessNetworkClient::BlockRequest br;
|
|
br.id=id;
|
|
br.offset=size_t(p_page)*page_size;
|
|
br.size=page_size;
|
|
nc->block_requests.push_back(br);
|
|
pages[p_page].queued=true;
|
|
nc->blockrequest_mutex->unlock();
|
|
DEBUG_PRINT("QUEUE PAGE POST");
|
|
nc->sem->post();
|
|
DEBUG_PRINT("queued "+itos(p_page));
|
|
}
|
|
|
|
}
|
|
|
|
int FileAccessNetwork::get_buffer(uint8_t *p_dst, int p_length) const{
|
|
|
|
//bool eof=false;
|
|
if (pos+p_length>total_size) {
|
|
eof_flag=true;
|
|
}
|
|
if (pos+p_length>=total_size) {
|
|
p_length=total_size-pos;
|
|
}
|
|
|
|
// FileAccessNetworkClient *nc = FileAccessNetworkClient::singleton;
|
|
|
|
uint8_t *buff=last_page_buff;
|
|
|
|
for(int i=0;i<p_length;i++) {
|
|
|
|
int page=pos/page_size;
|
|
|
|
if (page!=last_page) {
|
|
buffer_mutex->lock();
|
|
if (pages[page].buffer.empty()) {
|
|
//fuck
|
|
|
|
waiting_on_page=page;
|
|
for(int j=0;j<read_ahead;j++) {
|
|
|
|
_queue_page(page+j);
|
|
}
|
|
buffer_mutex->unlock();
|
|
DEBUG_PRINT("wait");
|
|
page_sem->wait();
|
|
DEBUG_PRINT("done");
|
|
} else {
|
|
|
|
for(int j=0;j<read_ahead;j++) {
|
|
|
|
_queue_page(page+j);
|
|
}
|
|
buff=pages[page].buffer.ptr();
|
|
//queue pages
|
|
buffer_mutex->unlock();
|
|
}
|
|
|
|
buff=pages[page].buffer.ptr();
|
|
last_page_buff=buff;
|
|
last_page=page;
|
|
}
|
|
|
|
p_dst[i]=buff[pos-uint64_t(page)*page_size];
|
|
pos++;
|
|
}
|
|
|
|
return p_length;
|
|
}
|
|
|
|
Error FileAccessNetwork::get_error() const{
|
|
|
|
return pos==total_size?ERR_FILE_EOF:OK;
|
|
}
|
|
|
|
void FileAccessNetwork::store_8(uint8_t p_dest) {
|
|
|
|
ERR_FAIL();
|
|
}
|
|
|
|
bool FileAccessNetwork::file_exists(const String& p_path){
|
|
|
|
FileAccessNetworkClient *nc = FileAccessNetworkClient::singleton;
|
|
nc->lock_mutex();
|
|
nc->put_32(id);
|
|
nc->put_32(COMMAND_FILE_EXISTS);
|
|
CharString cs=p_path.utf8();
|
|
nc->put_32(cs.length());
|
|
nc->client->put_data((const uint8_t*)cs.ptr(),cs.length());
|
|
nc->unlock_mutex();
|
|
DEBUG_PRINT("FILE EXISTS POST");
|
|
nc->sem->post();
|
|
sem->wait();
|
|
|
|
return exists_modtime!=0;
|
|
|
|
}
|
|
|
|
uint64_t FileAccessNetwork::_get_modified_time(const String& p_file){
|
|
|
|
FileAccessNetworkClient *nc = FileAccessNetworkClient::singleton;
|
|
nc->lock_mutex();
|
|
nc->put_32(id);
|
|
nc->put_32(COMMAND_GET_MODTIME);
|
|
CharString cs=p_file.utf8();
|
|
nc->put_32(cs.length());
|
|
nc->client->put_data((const uint8_t*)cs.ptr(),cs.length());
|
|
nc->unlock_mutex();
|
|
DEBUG_PRINT("MODTIME POST");
|
|
nc->sem->post();
|
|
sem->wait();
|
|
|
|
return exists_modtime;
|
|
|
|
}
|
|
|
|
void FileAccessNetwork::configure() {
|
|
|
|
GLOBAL_DEF("network/remote_fs/page_size",65536);
|
|
GLOBAL_DEF("network/remote_fs/page_read_ahead",4);
|
|
GLOBAL_DEF("network/remote_fs/max_pages",20);
|
|
|
|
}
|
|
|
|
FileAccessNetwork::FileAccessNetwork() {
|
|
|
|
eof_flag=false;
|
|
opened=false;
|
|
pos=0;
|
|
sem=Semaphore::create();
|
|
page_sem=Semaphore::create();
|
|
buffer_mutex=Mutex::create();
|
|
FileAccessNetworkClient *nc = FileAccessNetworkClient::singleton;
|
|
nc->lock_mutex();
|
|
id=nc->last_id++;
|
|
nc->accesses[id]=this;
|
|
nc->unlock_mutex();
|
|
page_size = GLOBAL_GET("network/remote_fs/page_size");
|
|
read_ahead = GLOBAL_GET("network/remote_fs/page_read_ahead");
|
|
max_pages = GLOBAL_GET("network/remote_fs/max_pages");
|
|
last_activity_val=0;
|
|
waiting_on_page=-1;
|
|
last_page=-1;
|
|
|
|
|
|
}
|
|
|
|
FileAccessNetwork::~FileAccessNetwork() {
|
|
|
|
close();
|
|
memdelete(sem);
|
|
memdelete(page_sem);
|
|
memdelete(buffer_mutex);
|
|
|
|
FileAccessNetworkClient *nc = FileAccessNetworkClient::singleton;
|
|
nc->lock_mutex();
|
|
id=nc->last_id++;
|
|
nc->accesses.erase(id);
|
|
nc->unlock_mutex();
|
|
|
|
}
|