boost::optional<boost::shared_ptr<Error> > TitleScene::OnSelect(boost::shared_ptr<Event> event) {
if(!event) {
return CREATE_ERROR(ERROR_CODE_INVALID_PARAMETER);
}
if(event->GetEventType() != EVENT_TYPE_ON_SELECT) {
return CREATE_ERROR(ERROR_CODE_INVALID_PARAMETER);
}
boost::shared_ptr<events::OnSelectEvent> on_select_event = boost::static_pointer_cast<events::OnSelectEvent>(event);
boost::shared_ptr<void> user_data = on_select_event->GetUserData();
if(!user_data) {
return CREATE_ERROR(ERROR_CODE_INVALID_PARAMETER);
}
boost::shared_ptr<NEXT> next = boost::static_pointer_cast<NEXT>(user_data);
switch(*next) {
case NEXT_LOAD_GAME:
OPT_ERROR(SaveDataLoad());
case NEXT_NEW_GAME:
next_scene.reset(new TownScene(default_frame_graph));
break;
case NEXT_EXIT:
exit = true;
break;
}
return boost::none;
}
boost::optional<boost::shared_ptr<Error> > UISelectorBase::Select(unsigned int index) {
if(index >= select_list.size()) {
return CREATE_ERROR(ERROR_CODE_SELECTOR_OUTSIDE_RANGE);
}
this->index = index;
return boost::none;
}
qioerr hdfs_get_owners_for_bytes(qio_file_t* file, hdfs_block_byte_map_t** locs, int* out_num_blocks, char** locale_array, int num_locales, off_t start_byte, off_t len)
{
int i;
int j = 0;
int k;
qioerr err = 0;
char* tmp;
int rnd;
int block_count = 0;
hdfs_block_byte_map_t* loc = NULL;
char*** info = NULL;
hdfsFileInfo* f_info = hdfsGetPathInfo(to_hdfs_fs(file->fs_info)->hfs, to_hdfs_file(file->file_info)->pathnm);
if (start_byte == 0 && len == -1) // We want the whole thing
info = hdfsGetHosts(to_hdfs_fs(file->fs_info)->hfs, to_hdfs_file(file->file_info)->pathnm, start_byte, f_info->mSize);
else info = hdfsGetHosts(to_hdfs_fs(file->fs_info)->hfs, to_hdfs_file(file->file_info)->pathnm, start_byte, start_byte + len);
while(info[block_count] != NULL) { // Get the number of blocks that we have
block_count++;
}
loc = (hdfs_block_byte_map_t*)qio_calloc(sizeof(hdfs_block_byte_map_t), block_count);
CREATE_ERROR((!info), err, EREMOTEIO, "Unable to get host for HDFS", end);
for (i = 0; info[i] != NULL; i++) { // Assign block owners
rnd = rand() % f_info->mReplication; // pick an owner
if (info[i][rnd]) {// Valid access
tmp = get_locale_name(info[i][rnd]); // strip off .___
for (k = 0; k < num_locales; k++) { // Now find the owner
if (strcmp(tmp, locale_array[k]) == 0) {
loc[i].locale_id = k; // return locale ID for that name
break;
}
}
loc[i].start_byte = (off_t)(i*f_info->mBlockSize);
loc[i].len = (off_t)(f_info->mBlockSize);
j++;
} else {
QIO_GET_CONSTANT_ERROR(err, EINVAL, "Unable to find address for blocks in hdfs_get_owners_for_bytes");
qio_free(loc);
*locs = NULL;
*out_num_blocks = 0;
goto end;
}
}
*locs = loc;
*out_num_blocks = j;
end:
return err;
}
boost::optional<boost::shared_ptr<Error> > FileRead(const std::wstring &path, std::vector<char> *data) {
if(path.empty() || data == NULL) {
return CREATE_ERROR(ERROR_CODE_INVALID_PARAMETER);
}
boost::shared_ptr<FILE> fp = MyFOpen(path, L"rb");
if(!fp) {
return CREATE_ERROR(ERROR_CODE_FILE_NOT_FOUND);
}
::fseek(fp.get(), 0, SEEK_END);
const long size = ::ftell(fp.get());
if(size < 0) {
return CREATE_ERROR(ERROR_CODE_INTERNAL_ERROR);
}
::fseek(fp.get(), 0, SEEK_SET);
data->resize(static_cast<unsigned int>(size));
const unsigned int read_size = ::fread(&data->front(), 1, data->size(), fp.get());
if(read_size != data->size()) {
return CREATE_ERROR(ERROR_CODE_INTERNAL_ERROR);
}
return boost::none;
}
qioerr hdfs_open(void** fd, const char* path, int* flags, mode_t mode, qio_hint_t iohints, void* fs)
{
qioerr err_out = 0;
int rc;
hdfs_file* fl = (hdfs_file*)qio_calloc(sizeof(hdfs_file), 1);
STARTING_SLOW_SYSCALL;
DO_RETAIN(((hdfs_fs*)fs));
// assert that we connected
CREATE_ERROR((to_hdfs_fs(fs)->hfs == NULL), err_out, ECONNREFUSED,"Unable to open HDFS file", error);
fl->file = hdfsOpenFile(to_hdfs_fs(fs)->hfs, path, *flags, 0, 0, 0);
// Assert that we opened the file
if (fl->file == NULL) {
err_out = qio_mkerror_errno();
goto error;
}
DONE_SLOW_SYSCALL;
fl->pathnm = path;
rc = *flags | ~O_ACCMODE;
rc &= O_ACCMODE;
if( rc == O_RDONLY ) {
*flags |= QIO_FDFLAG_READABLE;
} else if( rc == O_WRONLY ) {
*flags |= QIO_FDFLAG_WRITEABLE;
} else if( rc == O_RDWR ) {
*flags |= QIO_FDFLAG_READABLE;
*flags |= QIO_FDFLAG_WRITEABLE;
}
*fd = fl; // Set fd to fl and return
return err_out;
error:
qio_free(fl);
return err_out;
}
qioerr hdfs_connect(void** fs_out, const char* pathname, int port)
{
qioerr err_out = 0;
hdfsFS fs;
hdfs_fs* ret = (hdfs_fs*)qio_calloc(sizeof(hdfs_fs), 1);
STARTING_SLOW_SYSCALL;
fs = hdfsConnect(pathname, port);
CREATE_ERROR((fs == NULL), err_out, ECONNREFUSED,"Unable to connect HDFS", error);
DONE_SLOW_SYSCALL;
ret->hfs = fs;
DO_INIT_REFCNT(ret);
ret->fs_name = pathname;
ret->fs_port = port;
*fs_out = ret;
error:
return err_out;
}
qioerr hdfs_preadv (void* file, const struct iovec *vector, int count, off_t offset, ssize_t* num_read_out, void* fs)
{
ssize_t got;
ssize_t got_total;
qioerr err_out = 0;
int i;
STARTING_SLOW_SYSCALL;
#ifdef HDFS3
const hdfs_file orig_hfl = *to_hdfs_file(file);
const hdfs_fs orig_hfs = *to_hdfs_fs(fs);
hdfsFS hfs = hdfsConnect(orig_hfs.fs_name, orig_hfs.fs_port);
hdfsFile hfl = hdfsOpenFile(hfs, orig_hfl.pathnm, O_RDONLY, 0, 0, 0);
//assert connection
CREATE_ERROR((hfs == NULL), err_out, ECONNREFUSED, "Unable to read HDFS file", error);
if(hfl == NULL) {
err_out = qio_mkerror_errno();
goto error;
}
#endif
err_out = 0;
got_total = 0;
for(i = 0; i < count; i++) {
#ifdef HDFS3
hdfsSeek(hfs, hfl, offset+got_total);
got = hdfsRead(hfs, hfl, (void*)vector[i].iov_base, vector[i].iov_len);
#else
got = hdfsPread(to_hdfs_fs(fs)->hfs, to_hdfs_file(file)->file, offset + got_total, (void*)vector[i].iov_base, vector[i].iov_len);
#endif
if( got != -1 ) {
got_total += got;
} else {
err_out = qio_mkerror_errno();
break;
}
if(got != (ssize_t)vector[i].iov_len ) {
break;
}
}
if( err_out == 0 && got_total == 0 && sys_iov_total_bytes(vector, count) != 0 )
err_out = qio_int_to_err(EEOF);
*num_read_out = got_total;
#ifdef HDFS3
got = hdfsCloseFile(hfs, hfl);
if(got == -1) { err_out = qio_mkerror_errno(); }
got = hdfsDisconnect(hfs);
if(got == -1) { err_out = qio_mkerror_errno(); }
#endif
DONE_SLOW_SYSCALL;
#ifdef HDFS3
error:
#endif
return err_out;
}
