void target_manager::rebuild_targets(uint32_t screen, uint32_t style)
{
if (style == TARGET_STYLE_CUSTOM) return;
std::vector<bgfx_target*> to_resize;
for (std::pair<std::string, bgfx_target*> target_pair : m_targets)
{
bgfx_target* target = target_pair.second;
if (target == nullptr || target->style() != style || target->screen_index() != screen)
{
continue;
}
to_resize.push_back(target);
}
std::vector<osd_dim>& sizes = style == TARGET_STYLE_GUEST ? m_guest_dims : m_native_dims;
for (bgfx_target* target : to_resize)
{
std::string name = target->name();
const bgfx::TextureFormat::Enum format = target->format();
const bool double_buffered = target->double_buffered();
const bool filter = target->filter();
const uint16_t scale = target->scale();
const uint16_t width(sizes[screen].width());
const uint16_t height(sizes[screen].height());
delete target;
create_target(name, format, width, height, style, double_buffered, filter, scale, screen);
}
}
/**
* \brief Create the level.
*/
void rp::level_generator::create_level()
{
bear::universe::position_type pos(get_top_left());
bool previous_is_slope(false);
unsigned int last_paint = 0;
for(unsigned int i = 0; i != 100; i++ )
{
const double selector = (double)rand() / RAND_MAX;
if ( ( ( selector < 0.9 ) && previous_is_slope ) ||
( ( selector < 0.5 ) && ! previous_is_slope ) )
{
previous_is_slope = true;
add_slope(pos);
}
else
{
previous_is_slope = false;
add_ground(pos);
}
create_target(pos);
if ( ( ((double)rand() / RAND_MAX) < 0.1 ) &&
( i - last_paint > 50 ) )
{
last_paint = i;
create_bonus(pos);
}
}
} // rp::level_generator::create_level()
void target_manager::create_target_if_nonexistent(uint32_t screen, std::string name, bool double_buffered, bool filter, uint32_t style)
{
if (style == TARGET_STYLE_CUSTOM) return;
if (m_targets[name + std::to_string(screen)] != nullptr)
{
return;
}
std::vector<osd_dim>& sizes = style == TARGET_STYLE_GUEST ? m_guest_dims : m_native_dims;
uint16_t width(sizes[screen].width());
uint16_t height(sizes[screen].height());
create_target(name, bgfx::TextureFormat::RGBA8, width, height, style, double_buffered, filter, 1, screen);
}
/*
* Copy all relation data files from datadir_source to datadir_target, which
* are marked in the given data page map.
*/
void
copy_executeFileMap(filemap_t *map)
{
file_entry_t *entry;
int i;
for (i = 0; i < map->narray; i++)
{
entry = map->array[i];
execute_pagemap(&entry->pagemap, entry->path);
switch (entry->action)
{
case FILE_ACTION_NONE:
/* ok, do nothing.. */
break;
case FILE_ACTION_COPY:
rewind_copy_file_range(entry->path, 0, entry->newsize, true);
break;
case FILE_ACTION_TRUNCATE:
truncate_target_file(entry->path, entry->newsize);
break;
case FILE_ACTION_COPY_TAIL:
rewind_copy_file_range(entry->path, entry->oldsize,
entry->newsize, false);
break;
case FILE_ACTION_CREATE:
create_target(entry);
break;
case FILE_ACTION_REMOVE:
remove_target(entry);
break;
}
}
close_target_file();
}
/*
* Fetch all changed blocks from remote source data directory.
*/
void
libpq_executeFileMap(filemap_t *map)
{
file_entry_t *entry;
const char *sql;
PGresult *res;
int i;
/*
* First create a temporary table, and load it with the blocks that we
* need to fetch.
*/
sql = "CREATE TEMPORARY TABLE fetchchunks(path text, begin int8, len int4);";
res = PQexec(conn, sql);
if (PQresultStatus(res) != PGRES_COMMAND_OK)
pg_fatal("could not create temporary table: %s",
PQresultErrorMessage(res));
PQclear(res);
sql = "COPY fetchchunks FROM STDIN";
res = PQexec(conn, sql);
if (PQresultStatus(res) != PGRES_COPY_IN)
pg_fatal("could not send file list: %s",
PQresultErrorMessage(res));
PQclear(res);
for (i = 0; i < map->narray; i++)
{
entry = map->array[i];
/* If this is a relation file, copy the modified blocks */
execute_pagemap(&entry->pagemap, entry->path);
switch (entry->action)
{
case FILE_ACTION_NONE:
/* nothing else to do */
break;
case FILE_ACTION_COPY:
/* Truncate the old file out of the way, if any */
open_target_file(entry->path, true);
fetch_file_range(entry->path, 0, entry->newsize);
break;
case FILE_ACTION_TRUNCATE:
truncate_target_file(entry->path, entry->newsize);
break;
case FILE_ACTION_COPY_TAIL:
fetch_file_range(entry->path, entry->oldsize, entry->newsize);
break;
case FILE_ACTION_REMOVE:
remove_target(entry);
break;
case FILE_ACTION_CREATE:
create_target(entry);
break;
}
}
if (PQputCopyEnd(conn, NULL) != 1)
pg_fatal("could not send end-of-COPY: %s",
PQerrorMessage(conn));
while ((res = PQgetResult(conn)) != NULL)
{
if (PQresultStatus(res) != PGRES_COMMAND_OK)
pg_fatal("unexpected result while sending file list: %s",
PQresultErrorMessage(res));
PQclear(res);
}
/*
* We've now copied the list of file ranges that we need to fetch to the
* temporary table. Now, actually fetch all of those ranges.
*/
sql =
"SELECT path, begin, \n"
" pg_read_binary_file(path, begin, len, true) AS chunk\n"
"FROM fetchchunks\n";
receiveFileChunks(sql);
}
// flags = 0 -- syntax check only (first pass), flags = 1 -- create targets and points as well (second pass)
int parse_config (struct mc_config *MC, struct mc_config *MC_Old, int flags) {
int r, c, l, i;
struct hostent *h;
char *hostname;
int dup_port_checked, cluster_disabled;
if (!(flags & 1)) {
config_bytes = r = read (fd[0], config_buff, MAX_CONFIG_SIZE+1);
if (r < 0) {
fprintf (stderr, "error reading configuration file %s: %m\n", config_filename);
return -2;
}
if (r > MAX_CONFIG_SIZE) {
fprintf (stderr, "configuration file %s too long (max %d bytes)\n", config_filename, MAX_CONFIG_SIZE);
return -2;
}
}
cfg_cur = cfg_start = config_buff;
cfg_end = cfg_start + config_bytes;
*cfg_end = 0;
cfg_lno = 0;
if (!(flags & 1) && MC_Old) {
for (i = 0; i < MC_Old->clusters_num; i++) {
MC_Old->Clusters[i].other_cluster_no = -1;
}
}
MC->ConfigServersCount = 0;
MC->clusters_num = 0;
while (cfg_skipspc ()) {
struct mc_cluster *C = &MC->Clusters[MC->clusters_num];
if (cfg_getlex () != 'c') {
return syntax ("'cluster' expected");
}
assert (MC->clusters_num < MAX_CLUSTERS);
l = cfg_getword ();
if (!l) {
return syntax ("cluster name expected");
}
C->cluster_mode = default_cluster_mode;
memcpy (&C->mc_proxy_inbound, &mc_proxy_inbound, sizeof (struct memcache_server_functions));
C->mc_proxy_inbound.info = C;
C->cluster_no = MC->clusters_num++;
if (C->cluster_name) {
zfree (C->cluster_name, strlen (C->cluster_name) + 1);
}
C->cluster_name = zmalloc (l+1);
memcpy (C->cluster_name, cfg_cur, l);
C->cluster_name[l] = 0;
cfg_cur += l;
C->get_timeout = 0.3;
C->set_timeout = 0.5;
C->min_connections = default_min_connections;
C->max_connections = default_max_connections;
C->step = 0;
C->tot_buckets = 0;
C->port = 0;
C->points_num = 0;
C->crypto = 0;
dup_port_checked = 0;
cluster_disabled = 0;
C->a_req = C->a_rbytes = C->a_sbytes = C->a_timeouts = 0;
C->t_req = C->t_rbytes = C->t_sbytes = C->t_timeouts = 0;
if (!(flags & 1)) {
C->other_cluster_no = -1;
}
cfg_getlex ();
Expect ('{');
cfg_getlex ();
while (cfg_lex != '}') {
switch (cfg_lex) {
case 'l':
if (C->port) {
return syntax ("second listen in same cluster");
}
C->port = cfg_getint();
if (!C->port) {
return syntax ("port number expected");
}
if (C->port <= 0 || C->port >= 0x10000) {
return syntax("port number out of range");
}
if (!(flags & 1)) {
for (i = 0; i < MC->clusters_num-1; i++) {
if (MC->Clusters[i].port == C->port) {
return syntax ("duplicate listen port");
}
}
dup_port_checked = 1;
}
break;
case 'p':
if (C->points_num) {
return syntax ("redefined points number for same cluster");
}
C->points_num = cfg_getint ();
if (C->points_num < 0 || C->points_num > 1000) {
return syntax ("points number should be between 0 and 1000");
}
break;
case 'm':
l = cfg_getword ();
if (l == 9 && !memcmp (cfg_cur, "memcached", 9)) {
C->cluster_mode = (C->cluster_mode & -256) | CLUSTER_MODE_MEMCACHED;
} else if (l == 8 && !memcmp (cfg_cur, "firstint", 8)) {
C->cluster_mode = (C->cluster_mode & -256) | CLUSTER_MODE_FIRSTINT;
} else if (l == 6 && !memcmp (cfg_cur, "random", 6)) {
C->cluster_mode = (C->cluster_mode & -256) | CLUSTER_MODE_RANDOM;
} else if (l == 9 && !memcmp (cfg_cur, "secondint", 9)) {
C->cluster_mode = (C->cluster_mode & -256) | CLUSTER_MODE_SECONDINT;
} else if (l == 8 && !memcmp (cfg_cur, "thirdint", 8)) {
C->cluster_mode = (C->cluster_mode & -256) | CLUSTER_MODE_THIRDINT;
} else if (l == 9 && !memcmp (cfg_cur, "fourthint", 9)) {
C->cluster_mode = (C->cluster_mode & -256) | CLUSTER_MODE_FOURTHINT;
} else if (l == 8 && !memcmp (cfg_cur, "fifthint", 8)) {
C->cluster_mode = (C->cluster_mode & -256) | CLUSTER_MODE_FIFTHINT;
} else if (l == 10 && !memcmp (cfg_cur, "persistent", 10)) {
C->cluster_mode = (C->cluster_mode & -256) | CLUSTER_MODE_PERSISTENT;
} else {
return syntax ("unknown cluster mode");
}
cfg_cur += l;
break;
case 'e':
l = cfg_getword ();
if (l == 4 && !memcmp (cfg_cur, "text", 4)) {
C->cluster_mode |= CLUSTER_MODE_TEXT;
} else if (l == 5 && !memcmp (cfg_cur, "lists", 5)) {
C->cluster_mode |= CLUSTER_MODE_LISTS;
} else if (l == 5 && !memcmp (cfg_cur, "hints", 5)) {
C->cluster_mode |= CLUSTER_MODE_HINTS;
} else if (l == 4 && !memcmp (cfg_cur, "logs", 4)) {
C->cluster_mode |= CLUSTER_MODE_LOGS;
} else if (l == 5 && !memcmp (cfg_cur, "magus", 5)) {
C->cluster_mode |= CLUSTER_MODE_MAGUS;
} else if (l == 4 && !memcmp (cfg_cur, "news", 4)) {
C->cluster_mode |= CLUSTER_MODE_NEWS;
} else if (l == 10 && !memcmp (cfg_cur, "roundrobin", 10)) {
C->cluster_mode |= CLUSTER_MODE_ROUNDROBIN;
} else if (l == 5 && !memcmp (cfg_cur, "bayes", 5)) {
C->cluster_mode |= CLUSTER_MODE_BAYES;
} else if (l == 7 && !memcmp (cfg_cur, "support", 7)) {
C->cluster_mode |= CLUSTER_MODE_SUPPORT;
} else if (l == 5 && !memcmp (cfg_cur, "photo", 5)) {
C->cluster_mode |= CLUSTER_MODE_PHOTO;
} else if (l == 3 && !memcmp (cfg_cur, "dot", 3)) {
C->cluster_mode |= CLUSTER_MODE_DOT;
} else if (l == 4 && !memcmp (cfg_cur, "temp", 4)) {
C->cluster_mode |= CLUSTER_MODE_TEMP;
} else if (l == 8 && !memcmp (cfg_cur, "antispam", 8)) {
C->cluster_mode |= CLUSTER_MODE_ANTISPAM;
} else if (l == 6 && !memcmp (cfg_cur, "search", 6)){
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_SEARCH;
} else if (l == 4 && !memcmp (cfg_cur, "targ", 4)){
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_TARG;
} else if (l == 7 && !memcmp (cfg_cur, "news_ug", 7)) {
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_NEWS_UG;
} else if (l == 6 && !memcmp (cfg_cur, "news_g", 6)) {
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_NEWS_G;
} else if (l == 5 && !memcmp (cfg_cur, "newsr", 5)) {
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_NEWSR;
} else if (l == 9 && !memcmp (cfg_cur, "news_comm", 9)) {
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_NEWS_COMM;
} else if (l == 6 && !memcmp (cfg_cur, "statsx", 6)) {
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_STATSX;
} else if (l == 7 && !memcmp (cfg_cur, "friends", 7)) {
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_FRIENDS;
} else if (l == 7 && !memcmp (cfg_cur, "searchx", 7)) {
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_SEARCHX;
} else if (l == 8 && !memcmp (cfg_cur, "watchcat", 8)) {
C->cluster_mode |= CLUSTER_MODE_WATCHCAT;
} else if (l == 11 && !memcmp (cfg_cur, "hints_merge", 11)) {
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_HINTS_MERGE;
} else if (l == 12 && !memcmp (cfg_cur, "random_merge", 12)) {
if (C->cluster_mode & CLUSTER_MODE_MERGE) {
return syntax ("Can not enable two merge extensions");
}
C->cluster_mode |= CLUSTER_MODE_RANDOM_MERGE;
} else {
return syntax ("unknown extension");
}
cfg_cur += l;
break;
case 't':
C->get_timeout = cfg_getint ();
if (C->get_timeout < 10 || C->get_timeout > 30000) {
return syntax ("invalid timeout");
}
C->get_timeout /= 1000;
C->set_timeout = C->get_timeout + 0.2;
break;
case 'C':
C->crypto = 1;
break;
case 'T':
C->step = cfg_getint ();
if (C->step < 0) {
return syntax ("invalid step value");
}
break;
case 'G':
C->get_timeout = cfg_getint ();
if (C->get_timeout < 10 || C->get_timeout > 30000) {
return syntax ("invalid timeout");
}
C->get_timeout /= 1000;
break;
case 'S':
C->set_timeout = cfg_getint ();
if (C->set_timeout < 10 || C->set_timeout > 30000) {
return syntax ("invalid timeout");
}
C->set_timeout /= 1000;
break;
case 's':
assert (C->tot_buckets < MAX_CLUSTER_SERVERS);
l = cfg_getword ();
if (!l || l > 63) {
return syntax ("hostname expected");
}
c = cfg_cur[l];
hostname = cfg_cur;
cfg_cur[l] = 0;
if (!(h = kdb_gethostbyname (cfg_cur)) || h->h_addrtype != AF_INET || h->h_length != 4 || !h->h_addr_list || !h->h_addr) {
return syntax ("cannot resolve hostname");
}
default_ct.target = *((struct in_addr *) h->h_addr);
*(cfg_cur += l) = c;
cfg_getlex ();
Expect (':');
default_ct.port = cfg_getint();
if (!default_ct.port) {
return syntax ("port number expected");
}
if (default_ct.port <= 0 || default_ct.port >= 0x10000) {
return syntax ("port number out of range");
}
default_ct.min_connections = C->min_connections;
default_ct.max_connections = C->max_connections;
default_ct.reconnect_timeout = 1.0 + 0.1 * drand48 ();
default_ct.extra = (C->crypto ? &mc_proxy_outbound_crypto : &mc_proxy_outbound);
if ((flags & 1) && !cluster_disabled) {
int was_created = -1;
struct conn_target *D = create_target (&default_ct, &was_created);
if (was_created <= 0) {
// syntax_warning ("duplicate hostname:port %.*s:%d in cluster", l, hostname, default_ct.port);
}
MC->ConfigServers[MC->ConfigServersCount] = D;
C->buckets[C->tot_buckets] = D;
}
if (!cluster_disabled) {
C->tot_buckets++;
assert (MC->ConfigServersCount++ < MAX_CLUSTER_SERVERS);
}
vkprintf (1, "server #%d: ip %s, port %d\n", MC->ConfigServersCount, inet_ntoa (default_ct.target), default_ct.port);
break;
case 'X':
C->max_connections = cfg_getint ();
if (C->max_connections < C->min_connections || C->max_connections > 1000) {
return syntax ("invalid max connections");
}
break;
case 'x':
C->min_connections = cfg_getint ();
if (C->min_connections < 1 || C->min_connections > C->max_connections) {
return syntax ("invalid min connections");
}
break;
case 'd':
if (C->tot_buckets) {
return syntax ("'disabled' must appear before any server declaration in cluster");
}
cluster_disabled = 1;
// C->cluster_mode |= CLUSTER_MODE_DISABLED;
break;
case 0:
return syntax ("unexpected end of file");
default:
return syntax ("'server' expected");
}
cfg_getlex ();
Expect (';');
cfg_getlex ();
}
if (cluster_disabled) {
if (verbosity > 1) {
fprintf (stderr, "Cluster #%d (%s) on port %d, mode %04x : DISABLED\n", C->cluster_no, C->cluster_name, C->port, C->cluster_mode);
}
MC->clusters_num--;
continue;
}
if (!C->tot_buckets) {
return syntax ("no servers in clusters");
}
if (!C->port) {
C->port = port;
}
if (!(flags & 1) && !dup_port_checked) {
for (i = 0; i < MC->clusters_num - 1; i++) {
if (MC->Clusters[i].port == C->port) {
return syntax ("duplicate listen port");
}
}
}
if (!(flags & 1) && MC_Old) {
for (i = 0; i < MC_Old->clusters_num; i++) {
if (MC_Old->Clusters[i].port == C->port) {
MC_Old->Clusters[i].other_cluster_no = C->cluster_no;
C->other_cluster_no = i;
break;
}
}
}
if (C->points_num) {
if ((C->cluster_mode & 255) != CLUSTER_MODE_MEMCACHED) {
return syntax ("points can be defined for memcached mode clusters only");
}
if (flags & 1) {
build_mc_points (C);
}
}
if (verbosity > 1) {
fprintf (stderr, "Cluster #%d (%s) on port %d, mode %04x, %d servers\n", C->cluster_no, C->cluster_name, C->port, C->cluster_mode, C->tot_buckets);
}
if (only_first_cluster && MC->clusters_num >= only_first_cluster) {
break;
}
}
if (!MC->ConfigServersCount || !MC->clusters_num) {
return syntax ("no cluster defined");
}
return 0;
}
