예제 #1
0
static void
_manage_prefix(struct meta1_backend_s *m1, guint8 *prefix, sqlite3 *tmpdb)
{
	gchar sql[LIMIT_LENGTH_NSNAME + 128];

	int cb(void * u, int nbcols, char **vals, char **cols) {
		char *err_msg2 = NULL;

		(void) u;
		(void) nbcols;
		(void) cols;

		memset(sql, 0, sizeof(sql));
		g_snprintf(sql, sizeof(sql), "UPDATE vns SET size = size + %s "
				"WHERE vns = '%s'", vals[1], vals[0]);
		GRID_TRACE("_manage_prefix executing [%s]", sql);
		if (sqlite3_exec(tmpdb, sql, NULL, NULL, &err_msg2) != SQLITE_OK) {
			GRID_WARN("Could not update size for VNS %s: %s", vals[0], err_msg2);
		}
		sqlite3_free(err_msg2);
		err_msg2 = NULL;

		if (!sqlite3_changes(tmpdb)) { /* VNS not found */
			g_snprintf(sql, sizeof(sql), "INSERT INTO vns (vns,size) "
					"VALUES ('%s',%s)", vals[0], vals[1]);
			GRID_TRACE("_manage_prefix VNS not found, executing [%s]", sql);
			if (sqlite3_exec(tmpdb, sql, NULL, NULL, &err_msg2) != SQLITE_OK) {
				GRID_WARN("Could not set size for VNS %s: %s", vals[0], err_msg2);
			}
			sqlite3_free(err_msg2);
		}
		return 0;
	}
예제 #2
0
static GError*
_check(GList *working_m1list) {
	GError *error = NULL;

	if ( working_m1list ) {

		working_m1list=g_list_sort(working_m1list,meta0_assign_sort_by_score);
		struct meta0_assign_meta1_s *hM1 = working_m1list->data;
		struct meta0_assign_meta1_s *lM1 = (g_list_last(working_m1list))->data;
		guint highscore = hM1->score;
		guint lowscore = lM1->score;
		GRID_TRACE("check delta highscore %d ,lowscore %d",highscore,lowscore);
		if ( (highscore - lowscore) < (context->avgscore * trigger_assignment )/ 100  ) {
			GRID_WARN("New assign not necessary, high score %d , low score %d, average %d", highscore, lowscore, context->avgscore);
			error = NEWERROR(0, "New assign not necessary");
			return error;
		}
	}

	if ( context->lastAssignTime ) {
		GRID_TRACE("last time %s",g_date_time_format (context->lastAssignTime,"%Y-%m-%d %H:%M"));
		GDateTime *currentTime, *ltime;
		currentTime=g_date_time_new_now_local();
		ltime = g_date_time_add_minutes(context->lastAssignTime,period_between_two_assign);
		GRID_TRACE("currentTime :%s , last time + %d min :%s, comp :%d",g_date_time_format (currentTime,"%Y-%m-%d %H:%M"),period_between_two_assign,g_date_time_format (ltime,"%Y-%m-%d %H:%M"), g_date_time_compare(ltime,currentTime));
		if (g_date_time_compare(ltime,currentTime) > 0 ) {
			GRID_WARN("delay between two meta1 assign  not respected. Try later. last date [%s]",g_date_time_format (context->lastAssignTime,"%Y-%m-%d %H:%M"));
			error = NEWERROR(0,"delay between two meta1 assign  not respected. Try later.");
			return error;
		}
	}

	return NULL;
}
예제 #3
0
static void
_task_reconfigure_events (gpointer p)
{
	if (!grid_main_is_running ())
		return;
	if (!p || !PSRV(p)->events_queue)
		return;

	struct namespace_info_s *ni = PSRV(p)->nsinfo;
	if (!ni || !ni->options)
		return;

	gint64 i64 = OIO_EVTQ_MAXPENDING;
	gchar *k;

	/* without the prefix */
	i64 = gridcluster_get_nsinfo_int64 (ni, OIO_CFG_EVTQ_MAXPENDING, i64);
	GRID_TRACE("Looking for [%s]: %"G_GINT64_FORMAT, OIO_CFG_EVTQ_MAXPENDING, i64);

	/* with the prefix */
	k = g_strconcat (PSRV(p)->service_config->srvtype, ".",
			OIO_CFG_EVTQ_MAXPENDING, NULL);
	i64 = gridcluster_get_nsinfo_int64 (ni, k, i64);
	GRID_TRACE("Looking for [%s]: %"G_GINT64_FORMAT, k, i64);
	g_free(k);

	if (i64 >= 0 && i64 < G_MAXUINT) {
		guint u = (guint) i64;
		oio_events_queue__set_max_pending (PSRV(p)->events_queue, u);
	}
}
예제 #4
0
파일: grid.c 프로젝트: UIKit0/mctrl
static int
grid_get_geometry(grid_t* grid, MC_GGEOMETRY* geom)
{
    GRID_TRACE("grid_get_geometry(%p, %p)", grid, geom);

    if(MC_ERR((geom->fMask & ~GRID_GGF_ALL) != 0)) {
        MC_TRACE("grid_get_geometry: fMask has some unsupported bit(s)");
        SetLastError(ERROR_INVALID_PARAMETER);
        return -1;
    }

    if(geom->fMask & MC_GGF_COLUMNHEADERHEIGHT)
        geom->wColumnHeaderHeight = grid->header_height;
    if(geom->fMask & MC_GGF_ROWHEADERWIDTH)
        geom->wRowHeaderWidth = grid->header_width;
    if(geom->fMask & MC_GGF_DEFCOLUMNWIDTH)
        geom->wDefColumnWidth = grid->def_col_width;
    if(geom->fMask & MC_GGF_DEFROWHEIGHT)
        geom->wDefRowHeight = grid->def_row_height;
    if(geom->fMask & MC_GGF_PADDINGHORZ)
        geom->wPaddingHorz = grid->padding_h;
    if(geom->fMask & MC_GGF_PADDINGVERT)
        geom->wPaddingVert = grid->padding_v;

    return 0;
}
static GError *
__get_one_property(struct sqlx_sqlite3_s *sq3, struct oio_url_s *url, const gchar *name, GPtrArray *gpa)
{
	GError *err = NULL;
	sqlite3_stmt *stmt = NULL;
	int rc;

	GRID_TRACE("%s(n=%s)", __FUNCTION__, name);

	sqlite3_prepare_debug(rc, sq3->db,
			"SELECT name,value FROM properties WHERE cid = ? AND name = ?",
			-1, &stmt, NULL);
	if (rc != SQLITE_OK && rc != SQLITE_DONE)
		err = M1_SQLITE_GERROR(sq3->db, rc);
	else {
		(void) sqlite3_bind_blob(stmt, 1, oio_url_get_id(url), oio_url_get_id_size(url), NULL);
		(void) sqlite3_bind_text(stmt, 2, name, -1, NULL);
		while (SQLITE_ROW == (rc = sqlite3_step(stmt))) {
			g_ptr_array_add(gpa, item(stmt, 0));
			g_ptr_array_add(gpa, item(stmt, 1));
		}
		if (rc != SQLITE_OK && rc != SQLITE_DONE)
			err = M1_SQLITE_GERROR(sq3->db, rc);
		sqlite3_finalize_debug(rc, stmt);
	}

	return err;
}
예제 #6
0
void grid_changed_n_nodes()
{
  int per[3] = { 1, 1, 1 };
  GRID_TRACE(fprintf(stderr,"%d: grid_changed_n_nodes:\n",this_node));

  MPI_Comm_free(&comm_cart);
  
  MPI_Cart_create(MPI_COMM_WORLD, 3, node_grid, per, 0, &comm_cart);

  MPI_Comm_rank(comm_cart, &this_node);

  MPI_Cart_coords(comm_cart, this_node, 3, node_pos);

  calc_node_neighbors(this_node);

#ifdef GRID_DEBUG
  fprintf(stderr,"%d: node_pos=(%d,%d,%d)\n",this_node,node_pos[0],node_pos[1],node_pos[2]);
  fprintf(stderr,"%d: node_neighbors=(%d,%d,%d,%d,%d,%d)\n",this_node,
	  node_neighbors[0],node_neighbors[1],node_neighbors[2],
	  node_neighbors[3],node_neighbors[4],node_neighbors[5]);
  fprintf(stderr,"%d: boundary=(%d,%d,%d,%d,%d,%d)\n",this_node,
	  boundary[0],boundary[1],boundary[2],boundary[3],boundary[4],boundary[5]);
#endif

  grid_changed_box_l();
}
예제 #7
0
static void
_task_reconfigure_events (gpointer p)
{
	if (!grid_main_is_running ())
		return;
	if (!p || !PSRV(p)->events_queue)
		return;

	struct namespace_info_s *ni = PSRV(p)->nsinfo;
	if (!ni || !ni->options)
		return;

	gint64 i64 = namespace_info_get_srv_param_i64(ni, NULL,
			PSRV(p)->service_config->srvtype,
			OIO_CFG_EVTQ_MAXPENDING,
			OIO_EVTQ_MAXPENDING);
	GRID_TRACE("Looking for [%s]: %"G_GINT64_FORMAT,
			OIO_CFG_EVTQ_MAXPENDING, i64);

	if (i64 >= 0 && i64 < G_MAXUINT) {
		guint u = (guint) i64;
		oio_events_queue__set_max_pending (PSRV(p)->events_queue, u);
	}

	i64 = namespace_info_get_srv_param_i64(ni, NULL,
			PSRV(p)->service_config->srvtype,
			OIO_CFG_EVTQ_BUFFER_DELAY,
			OIO_EVTQ_BUFFER_DELAY);
	if (i64 >= 0 && i64 < 3600) {
		oio_events_queue__set_buffering(PSRV(p)->events_queue,
				i64 * G_TIME_SPAN_SECOND);
	}
}
예제 #8
0
파일: grid.c 프로젝트: UIKit0/mctrl
static int
grid_resize_table(grid_t* grid, WORD col_count, WORD row_count)
{
    GRID_TRACE("grid_resize_table(%d, %d)", (int) col_count, (int) row_count);

    if(grid->table != 0) {
        if(MC_ERR(table_resize(grid->table, col_count, row_count) != 0)) {
            MC_TRACE("grid_resize_table: table_resize() failed.");
            return -1;
        }
    } else {
        if(grid->col_widths != NULL)
            grid_alloc_col_widths(grid, grid->col_count, col_count, TRUE);
        if(grid->row_heights)
            grid_alloc_row_heights(grid, grid->row_count, row_count, TRUE);

        grid->col_count = col_count;
        grid->row_count = row_count;

        if(!grid->no_redraw) {
            InvalidateRect(grid->win, NULL, TRUE);
            grid_setup_scrollbars(grid, TRUE);
        }
    }

    return 0;
}
예제 #9
0
static GError*
_open_and_lock(struct meta0_backend_s *m0, enum m0v2_open_type_e how,
		struct sqlx_sqlite3_s **handle)
{
	GError *err = NULL;

	EXTRA_ASSERT(m0 != NULL);
	EXTRA_ASSERT(handle != NULL);

	/* Now open/lock the base in a way suitable for our op */
	guint flag = m0_to_sqlx(how);
	struct sqlx_name_s n = {.base=m0->ns, .type=NAME_SRVTYPE_META0, .ns=m0->ns};
	err = sqlx_repository_open_and_lock(m0->repository, &n, flag, handle, NULL);

	if (err != NULL) {
		if (!CODE_IS_REDIRECT(err->code))
			g_prefix_error(&err, "Open/Lock error: ");
		return err;
	}

	EXTRA_ASSERT(*handle != NULL);
	GRID_TRACE("Opened and locked [%s/%s]", m0->id, NAME_SRVTYPE_META0);

	return NULL;
}

static void
_unlock_and_close(struct sqlx_sqlite3_s *sq3)
{
	EXTRA_ASSERT(sq3 != NULL);
	sqlx_admin_save_lazy (sq3);
	sqlx_repository_unlock_and_close_noerror(sq3);
}
예제 #10
0
void calc_node_neighbors(int node)
{
  int dir;
  
  map_node_array(node,node_pos);
  for(dir=0;dir<3;dir++) {
    int buf;
    MPI_Cart_shift(comm_cart, dir, -1, &buf, node_neighbors + 2*dir);
    MPI_Cart_shift(comm_cart, dir, 1, &buf, node_neighbors + 2*dir + 1);

    /* left boundary ? */
    if (node_pos[dir] == 0) {
      boundary[2*dir] = 1;
    }
    else {
      boundary[2*dir] = 0;
    }
    /* right boundary ? */
   if (node_pos[dir] == node_grid[dir]-1) {
      boundary[2*dir+1] = -1;
    }
    else {
      boundary[2*dir+1] = 0;
    }
  }
  GRID_TRACE(printf("%d: node_grid %d %d %d, pos %d %d %d, node_neighbors ", this_node, node_grid[0], node_grid[1], node_grid[2], node_pos[0], node_pos[1], node_pos[2]));
}
static GError *
__replace_property(struct sqlx_sqlite3_s *sq3, struct oio_url_s *url,
		const gchar *name, const gchar *value)
{
	GError *err = NULL;
	gint rc;
	sqlite3_stmt *stmt = NULL;

	EXTRA_ASSERT(name != NULL && *name != '\0');
	EXTRA_ASSERT(value != NULL && *value != '\0');
	GRID_TRACE("%s(n=%s,v=%s)", __FUNCTION__, name, value);

	sqlite3_prepare_debug(rc, sq3->db,
			"REPLACE INTO properties (name,value,cid) VALUES (?,?,?)", -1, &stmt, NULL);
	if (rc != SQLITE_OK && rc != SQLITE_DONE)
		err = M1_SQLITE_GERROR(sq3->db, rc);
	else {
		(void) sqlite3_bind_text(stmt, 1, name, -1, NULL);
		(void) sqlite3_bind_text(stmt, 2, value, -1, NULL);
		(void) sqlite3_bind_blob(stmt, 3, oio_url_get_id(url), oio_url_get_id_size(url), NULL);
		sqlite3_step_debug_until_end (rc, stmt);
		if (rc != SQLITE_DONE && rc != SQLITE_OK)
			err = M1_SQLITE_GERROR(sq3->db, rc);
		sqlite3_finalize_debug(rc, stmt);
	}

	return err;
}
예제 #12
0
static struct meta0_assign_meta1_s*  
_select_source_assign_m1(GList *lst, guint8 *treat_prefixes, const guint avgscore)
{
	if (lst == NULL )
		return NULL;
	struct meta0_assign_meta1_s *aM1 =(g_list_first(lst))->data;

	if (aM1->score <= avgscore)
		return NULL;

	// check current prefix 
	GArray *prefixes = aM1->assignPrefixes;
	if (prefixes) { 
		if (!_select_prefix(prefixes,treat_prefixes)) {
			aM1->available=FALSE;
			aM1->assignPrefixes=NULL;
		}
	} else {
		aM1->available=FALSE;
	}

	if (!aM1->available) {
		lst=g_list_delete_link(lst,lst);
		return _select_source_assign_m1(lst, treat_prefixes,avgscore);
	}

	GRID_TRACE("select source meta1 %s, score %d",aM1->addr,aM1->score);
	return aM1;
}
예제 #13
0
static gboolean
_select_prefix(GArray *prefixes, guint8 *treat_prefixes)
{
	if (!prefixes) {
		return FALSE;
	}

	if ( prefixes->len != 0 ) {
		guint8 *prefix = (guint8 *)prefixes->data;
		if(!_is_treat_prefix(treat_prefixes,prefix)) {
			GRID_TRACE("select prefix %02X%02X ",prefix[0],prefix[1]);
			return TRUE;
		}

		prefixes=g_array_remove_index(prefixes,0);	

		if ( prefixes->len != 0 ) {
			return _select_prefix(prefixes,treat_prefixes);
		} 
	}

	g_array_free(prefixes,TRUE);
	prefixes=NULL;

	return FALSE;
}
예제 #14
0
static GError *
_reload(struct meta0_backend_s *m0, gboolean lazy)
{
	GError *err = NULL;

	EXTRA_ASSERT(m0 != NULL);
	GRID_TRACE("%s(%p,lazy=%d)", __FUNCTION__, m0, lazy);

	g_rw_lock_writer_lock(&(m0->rwlock));

	if (!lazy || m0->reload_requested || !m0->array_by_prefix || !m0->array_meta1_ref) {
		if (m0->array_by_prefix) {
			meta0_utils_array_clean(m0->array_by_prefix);
			m0->array_by_prefix = NULL;
		}
		if (m0->array_meta1_ref) {
			meta0_utils_array_meta1ref_clean(m0->array_meta1_ref);
			m0->array_meta1_ref = NULL;
		}

		err = _load(m0);
		m0->reload_requested = FALSE;
		if (NULL != err)
			g_prefix_error(&err, "Loading error: ");
	}

	g_rw_lock_writer_unlock(&(m0->rwlock));
	return err;
}
예제 #15
0
static enum http_rc_e
handler_action (struct http_request_s *rq, struct http_reply_ctx_s *rp)
{
	// Get a request id for the current request
	const gchar *reqid = g_tree_lookup (rq->tree_headers, PROXYD_HEADER_REQID);
	if (reqid)
		oio_ext_set_reqid(reqid);
	else
		oio_ext_set_random_reqid();

	// Then parse the request to find a handler
	struct oio_url_s *url = NULL;
	struct oio_requri_s ruri = {NULL, NULL, NULL, NULL};
	oio_requri_parse (rq->req_uri, &ruri);

	struct path_matching_s **matchings = _metacd_match (rq->cmd, ruri.path);

	GRID_TRACE2("URI path[%s] query[%s] fragment[%s] matches[%u]",
			ruri.path, ruri.query, ruri.fragment,
			g_strv_length((gchar**)matchings));

	GQuark gq_count = gq_count_unexpected;
	GQuark gq_time = gq_time_unexpected;

	enum http_rc_e rc;
	if (!*matchings) {
		rp->set_content_type ("application/json");
		rp->set_body_gstr (g_string_new("{\"status\":404,\"message\":\"No handler found\"}"));
		rp->set_status (HTTP_CODE_NOT_FOUND, "No handler found");
		rp->finalize ();
		rc = HTTPRC_DONE;
	} else {
		struct req_args_s args = {0};
		args.req_uri = &ruri;
		args.matchings = matchings;
		args.rq = rq;
		args.rp = rp;

		args.url = url = _metacd_load_url (&args);
		rp->subject(oio_url_get(url, OIOURL_HEXID));
		gq_count = (*matchings)->last->gq_count;
		gq_time = (*matchings)->last->gq_time;
		GRID_TRACE("%s %s URL %s", __FUNCTION__, ruri.path, oio_url_get(args.url, OIOURL_WHOLE));
		req_handler_f handler = (*matchings)->last->u;
		rc = (*handler) (&args);
	}

	gint64 spent = oio_ext_monotonic_time () - rq->client->time.evt_in;

	network_server_stat_push4 (rq->client->server, TRUE,
			gq_count, 1, gq_count_all, 1,
			gq_time, spent, gq_time_all, spent);

	path_matching_cleanv (matchings);
	oio_requri_clear (&ruri);
	oio_url_pclean (&url);
	oio_ext_set_reqid (NULL);
	return rc;
}
예제 #16
0
파일: grid.c 프로젝트: UIKit0/mctrl
static void
grid_notify_format(grid_t* grid)
{
    LRESULT lres;
    lres = MC_SEND(grid->notify_win, WM_NOTIFYFORMAT, grid->win, NF_QUERY);
    grid->unicode_notifications = (lres == NFR_UNICODE ? 1 : 0);
    GRID_TRACE("grid_notify_format: Will use %s notifications.",
               grid->unicode_notifications ? "Unicode" : "ANSI");
}
예제 #17
0
void
version_debug(const gchar *tag, GTree *versions)
{
	if (!GRID_TRACE_ENABLED())
		return;

	(void) tag;
	gchar *s = version_dump(versions);
	GRID_TRACE("%s %s (%s)", tag, s, __FUNCTION__);
	g_free(s);
}
예제 #18
0
파일: main.c 프로젝트: korween/oio-sds
static void
monitor_get_status(const gchar *monitor_cmd, service_info_t *si)
{
	gchar *str_si;

	if (strlen(monitor_cmd) > 0) {
		GRID_TRACE("Collecting the service state");
		parse_output(monitor_cmd, si);
		str_si =  service_info_to_string(si);
		GRID_DEBUG("SVC state: %s", str_si);
		g_free(str_si);
	}
}
예제 #19
0
void grid_changed_box_l()
{
  int i;

  GRID_TRACE(fprintf(stderr,"%d: grid_changed_box_l:\n",this_node));
  GRID_TRACE(fprintf(stderr,"%d: node_pos %d %d %d\n", this_node, node_pos[0], node_pos[1], node_pos[2]));
  GRID_TRACE(fprintf(stderr,"%d: node_grid %d %d %d\n", this_node, node_grid[0], node_grid[1], node_grid[2]));
  for(i = 0; i < 3; i++) {
    local_box_l[i] = box_l[i]/(double)node_grid[i]; 
    my_left[i]   = node_pos[i]    *local_box_l[i];
    my_right[i]  = (node_pos[i]+1)*local_box_l[i];    
    box_l_i[i] = 1/box_l[i];
  }

  calc_minimal_box_dimensions();

#ifdef GRID_DEBUG
  fprintf(stderr,"%d: local_box_l = (%.3f, %.3f, %.3f)\n",this_node,
	  local_box_l[0],local_box_l[1],local_box_l[2]);
  fprintf(stderr,"%d: coordinates: x in [%.3f, %.3f], y in [%.3f, %.3f], z in [%.3f, %.3f]\n",this_node,
	  my_left[0],my_right[0],my_left[1],my_right[1],my_left[2],my_right[2]);
#endif
}
예제 #20
0
	/* Test if a list has one and only one element */
	gboolean _has_only_one_element(gpointer k, gpointer v, gpointer d) {
		(void) d;
		GSList *chunk_list = (GSList *) v;
		guint length = g_slist_length(chunk_list);
		if (GRID_DEBUG_ENABLED()) {
			GString *hash_str = metautils_gba_to_hexgstr(NULL, (GByteArray *) k);
			if (length == 1) {
				GRID_TRACE("Removing bean of hash '%s' from hash table", hash_str->str);
			} else {
				GRID_DEBUG("Found % 4d beans with hash '%s'",
						length, hash_str->str);
			}
			g_string_free(hash_str, TRUE);
		}
		return (length == 1);
	}
예제 #21
0
파일: slab.c 프로젝트: Narthorn/oio-sds
void
data_slab_sequence_trace(struct data_slab_sequence_s *dss)
{
	struct data_slab_s *s;

	if (!GRID_TRACE_ENABLED())
		return;

	GRID_TRACE(" DSS %p -> %p", dss->first, dss->last);
	for (s = dss->first; s ;) {
		data_slab_trace("SLAB", s);
		if (s == dss->last)
			break;
		s = s->next;
	}
}
예제 #22
0
void
http_put_feed (struct http_put_s *p, GBytes *b)
{
	g_assert (p != NULL);
	g_assert (b != NULL);
	gssize len = g_bytes_get_size (b);
	GRID_TRACE("%s (%p) <- %"G_GSIZE_FORMAT, __FUNCTION__, p, len);
	g_assert (len <= 0 || p->remaining_length < 0 || len <= p->remaining_length);

	g_queue_push_tail (p->buffer_tail, b);

	if (!len) { /* marker for end of stream */
		p->remaining_length = 0;
	} else {
		p->remaining_length -= len;
	}
}
예제 #23
0
파일: rawx.c 프로젝트: amogrid/redcurrant
static gboolean _ne_request(const char *host, int port, const char *target,
		const char *method, GSList *headers, GError **err)
{
	GRID_TRACE("%s", __FUNCTION__);
	gboolean result = FALSE;
	ne_session* session = ne_session_create("http", host, port);
	ne_set_connect_timeout(session, 10);
	ne_set_read_timeout(session, 30);

	GRID_DEBUG("%s http://%s:%d%s", method, host, port, target);
	ne_request* req = ne_request_create(session, method, target);
	if (NULL != req) {
		for (GSList *l = headers; l; l = l->next) {
			gchar **toks = g_strsplit(l->data, ":", 2);
			ne_add_request_header(req, toks[0], toks[1]);
			g_strfreev(toks);
		}
		switch (ne_request_dispatch(req)) {
			case NE_OK:
				if (ne_get_status(req)->klass != 2) {
					*err = NEWERROR(0, "cannot %s '%s' (%s)", method, target,
							ne_get_error(session));
				} else {
					result = TRUE;
				}
				break;
			case NE_AUTH:
			case NE_CONNECT:
			case NE_TIMEOUT:
			case NE_ERROR:
			default:
				*err = NEWERROR(0,
						"unexpected error from the WebDAV server (%s)",
						ne_get_error(session));
				break;
		}
		ne_request_destroy(req);
	} else {
		// This should be an assertion
		*err = NEWERROR(0, "Failed to create request");
	}
	ne_session_destroy (session);
	return result;
}
예제 #24
0
static gboolean
_configure_backend(struct sqlx_service_s *ss)
{
	struct sqlx_repo_config_s repository_config = {0};
	repository_config.flags = 0;
	repository_config.flags |= ss->flag_delete_on ? SQLX_REPO_DELETEON : 0;
	repository_config.flags |= ss->flag_cached_bases ? 0 : SQLX_REPO_NOCACHE;
	repository_config.flags |= ss->flag_autocreate ? SQLX_REPO_AUTOCREATE : 0;
	repository_config.sync_solo = ss->sync_mode_solo;
	repository_config.sync_repli = ss->sync_mode_repli;

	repository_config.page_size = SQLX_DEFAULT_PAGE_SIZE;
	if (ss->cfg_page_size >= 512)
		repository_config.page_size = ss->cfg_page_size;

	GError *err = sqlx_repository_init(ss->volume, &repository_config,
			&ss->repository);
	if (err) {
		GRID_ERROR("SQLX repository init failure : (%d) %s",
				err->code, err->message);
		g_clear_error(&err);
		return FALSE;
	}

	err = sqlx_repository_configure_type(ss->repository,
			ss->service_config->srvtype, ss->service_config->schema);

	if (err) {
		GRID_ERROR("SQLX schema init failure : (%d) %s", err->code, err->message);
		g_clear_error(&err);
		return FALSE;
	}

	sqlx_repository_configure_open_timeout (ss->repository,
			ss->open_timeout * G_TIME_SPAN_MILLISECOND);

	sqlx_repository_configure_hash (ss->repository,
			ss->service_config->repo_hash_width,
			ss->service_config->repo_hash_depth);

	GRID_TRACE("SQLX repository initiated");
	return TRUE;
}
예제 #25
0
GError *
oio_sqlx_client__execute_statement (struct oio_sqlx_client_s *self,
		const char *in_stmt, gchar **in_params,
		struct oio_sqlx_output_ctx_s *out_ctx, gchar ***out_lines)
{
	GError *err = NULL;
	struct oio_sqlx_batch_s *batch = NULL;
	struct oio_sqlx_batch_result_s *result = NULL;

	GRID_TRACE("%s (%p, %s)", __FUNCTION__, self, in_stmt);

	(void) oio_sqlx_client_factory__batch (NULL, &batch);
	oio_sqlx_batch__add (batch, in_stmt, in_params);
	err = oio_sqlx_client__execute_batch (self, batch, &result);
	oio_sqlx_batch__destroy (batch);

	if (err) {
		g_assert (result == NULL);
		return err;
	}

	g_assert (result != NULL);
	guint count = oio_sqlx_batch_result__count_statements (result);
	g_assert (count == 1);
	guint count_lines = 0;
	err = oio_sqlx_batch_result__get_statement (result, 0, &count_lines, out_ctx);
	if (!err && out_lines) {
		GPtrArray *tmp = g_ptr_array_new ();
		for (guint i=0; i<count_lines ;++i) {
			gchar **fields = oio_sqlx_batch_result__get_row (result, 0, i);
			g_ptr_array_add (tmp, g_strjoinv (",", fields));
			g_strfreev (fields);
		}
		g_ptr_array_add (tmp, NULL);
		*out_lines = (gchar**) g_ptr_array_free (tmp, FALSE);
	}
	oio_sqlx_batch_result__destroy (result);

	return err;
}
예제 #26
0
static void
parse_chunkinfo_from_rawx(GHashTable *ht, struct content_textinfo_s *content,
    struct chunk_textinfo_s *chunk)
{
	GHashTableIter iterator;
	gpointer key, value;

	g_hash_table_iter_init(&iterator, ht);

	while (g_hash_table_iter_next(&iterator, &key, &value)) {
		GRID_TRACE("key (%s) / value (%s)", (gchar*)key, (gchar*)value);
		if (0 == g_ascii_strcasecmp(RAWXATTR_NAME_CHUNK_ID, key))
			chunk->id = g_strdup(value);
		else if (0 == g_ascii_strcasecmp(RAWXATTR_NAME_CHUNK_SIZE, key))
			chunk->size = g_strdup(value);
		else if (0 == g_ascii_strcasecmp(RAWXATTR_NAME_CHUNK_HASH, key))
			chunk->hash = g_strdup(value);
		else if (0 == g_ascii_strcasecmp(RAWXATTR_NAME_CHUNK_POS, key))
			chunk->position = g_strdup(value);
		else if (0 == g_ascii_strcasecmp(RAWXATTR_NAME_CHUNK_METADATA, key))
			chunk->metadata = g_strdup(value);
		else if (0 == g_ascii_strcasecmp(RAWXATTR_NAME_CONTENT_PATH, key)) {
			chunk->path = g_strdup(value);
			content->path = g_strdup(value);
		}
		else if (0 == g_ascii_strcasecmp(RAWXATTR_FROM_HEAD_CONTENT_CONTAINERID, key)) {
			chunk->container_id = g_strdup(value);
			content->container_id = g_strdup(value);
		}
		else if (0 == g_ascii_strcasecmp(RAWXATTR_NAME_CONTENT_SIZE, key))
			content->size = g_strdup(value);
		else if (0 == g_ascii_strcasecmp(RAWXATTR_FROM_HEAD_CONTENT_CHUNKSNB, key))
			content->chunk_nb = g_strdup(value);
		else if (0 == g_ascii_strcasecmp(RAWXATTR_NAME_CONTENT_METADATA, key))
			content->metadata = g_strdup(value);
		else if (0 == g_ascii_strcasecmp(RAWXATTR_FROM_HEAD_CONTENT_METADATA_SYS, key))
			content->system_metadata = g_strdup(value);
	}
}
예제 #27
0
GError*
compound_type_parse(struct compound_type_s *ct, const gchar *srvtype)
{
	EXTRA_ASSERT(ct != NULL);
	memset(ct, 0, sizeof(struct compound_type_s));

	if (!srvtype || !*srvtype || *srvtype == '.' || *srvtype == ';')
		return NEWERROR(CODE_BAD_REQUEST, "Bad service type [%s]", srvtype);

	ct->fulltype = srvtype;

	gchar **tokens = g_strsplit(srvtype, ";", 2);
	_parse_type(ct, tokens[0]);
	_parse_args(ct, tokens[1]);
	g_free(tokens);

	GRID_TRACE("CT full[%s] type[%s] bare[%s] sub[%s] args[%s|%s]",
			ct->fulltype, ct->type, ct->baretype, ct->subtype,
			ct->req.k, ct->req.v);

	return NULL;
}
static int
_send (int fd, struct iovec *iov, unsigned int iovcount)
{
	int w;
retry:
	w = writev (fd, iov, iovcount);
	if (w < 0) {
		if (errno == EINTR)
			goto retry;
		if (errno == EAGAIN || errno == EWOULDBLOCK) {
			struct pollfd pfd = {0};
			pfd.fd = fd;
			pfd.events = POLLOUT;
			metautils_syscall_poll (&pfd, 1, 1000);
			goto retry;
		}
		GRID_WARN("BEANSTALKD failed to put: [errno=%d] %s",
				errno, strerror(errno));
		return 0;
	}

	while (w > 0 && iovcount > 0) {
		if (iov[0].iov_len <= (size_t)w) {
			w -= iov[0].iov_len;
			iov[0].iov_len = 0;
			iov ++;
			iovcount --;
		} else {
			iov[0].iov_len -= w;
			w = 0;
		}
	}
	if (iovcount > 0)
		goto retry;

	GRID_TRACE("BEANSTALKD put sent!");
	return 1;
}
예제 #29
0
파일: grid.c 프로젝트: UIKit0/mctrl
static int
grid_set_geometry(grid_t* grid, MC_GGEOMETRY* geom, BOOL invalidate)
{
    GRID_TRACE("grid_set_geometry(%p, %p, %d)", grid, geom, (int)invalidate);

    if(geom != NULL) {
        if(geom->fMask & MC_GGF_COLUMNHEADERHEIGHT)
            grid->header_height = geom->wColumnHeaderHeight;
        if(geom->fMask & MC_GGF_ROWHEADERWIDTH)
            grid->header_width = geom->wRowHeaderWidth;
        if(geom->fMask & MC_GGF_DEFCOLUMNWIDTH)
            grid->def_col_width = geom->wDefColumnWidth;
        if(geom->fMask & MC_GGF_DEFROWHEIGHT)
            grid->def_row_height = geom->wDefRowHeight;
        if(geom->fMask & MC_GGF_PADDINGHORZ)
            grid->padding_h = geom->wPaddingHorz;
        if(geom->fMask & MC_GGF_PADDINGVERT)
            grid->padding_v = geom->wPaddingVert;
    } else {
        SIZE font_size;

        mc_font_size(NULL, &font_size, TRUE);
        grid->padding_h = CELL_DEF_PADDING_H;
        grid->padding_v = CELL_DEF_PADDING_V;
        grid->header_width = 6 * font_size.cx + 2 * grid->padding_h;
        grid->header_height = font_size.cy + 2 * grid->padding_v;
        grid->def_col_width = 8 * font_size.cx + 2 * grid->padding_h;
        grid->def_row_height = font_size.cy + 2 * grid->padding_v;
    }

    grid_setup_scrollbars(grid, TRUE);

    if(invalidate && !grid->no_redraw)
        InvalidateRect(grid->win, NULL, TRUE);

    return 0;
}
예제 #30
0
static gboolean
_get_attr_from_handle(struct attr_handle_s *attr_handle, GError ** error,
		const char *domain, const char *attrname, gchar **result)
{
	char key[ATTR_NAME_MAX_LENGTH], *value;

	if (!attr_handle || !domain || !attrname || !result) {
		SETERRCODE(error, EINVAL, "Invalid argument (%p %p %p %p)",
			attr_handle, domain, attrname, result);
		return FALSE;
	}

	g_snprintf(key, sizeof(key), "%s.%s", domain, attrname);

	value = g_hash_table_lookup(attr_handle->attr_hash, key);

	if (value)
		*result = g_strdup(value);
	else {
		GRID_TRACE("Attribute [%s] not found for chunk [%s]", key, attr_handle->chunk_path);
		*result = NULL;
	}
	return TRUE;
}