godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/core/io/file_access_network.cpp

568 lines
12 KiB
C++
Raw Blame History

/*************************************************************************/
/* file_access_network.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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;
}
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_DEF("remote_fs/page_size",65536);
read_ahead = GLOBAL_DEF("remote_fs/page_read_ahead",4);
max_pages = GLOBAL_DEF("remote_fs/max_pages",20);
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();
}
Reference in New Issue View Git Blame Copy Permalink