C++ create_session函数代码示例

//-----------------------------------------------------------------------------
worker_c::error_e worker_c::service_handshake_request( Reveal::Core::authorization_ptr auth ) { 

  Reveal::Core::session_ptr session;
  Reveal::Core::user_ptr user;

  Reveal::Core::authorization_c::type_e type = auth->get_type();
  if( type == Reveal::Core::authorization_c::TYPE_IDENTIFIED ) {
    // validate user credentials

    printf( "client requested identified authorization: id[%s]\n", auth->get_user().c_str() );

    // TODO : Logging

    if( is_user_valid( auth, user ) ) {
      if( create_session( auth, session ) ) {
        printf( "created session: " ); session->print();

        auth->set_error( Reveal::Core::authorization_c::ERROR_NONE );
        auth->set_user( user->id );
        auth->set_type( Reveal::Core::authorization_c::TYPE_SESSION );
        auth->set_session( session->session_id );

        send_valid_handshake_response( auth );
      } else {
        // TODO : handle failed session insert into database

      }
    } else {
      printf( "ERROR: failed to find %s in user table\n", auth->get_user().c_str() );

      // failed query and failed authentication
      auth->set_error( Reveal::Core::authorization_c::ERROR_INVALID_IDENTITY );

      send_invalid_handshake_response( auth );
    }
  } else if( type == Reveal::Core::authorization_c::TYPE_ANONYMOUS ) {

    printf( "client requested anonymous authorization\n" );

    // TODO : Logging

    if( create_session( auth, session ) ) {
      printf( "created session: " ); session->print();

      auth->set_type( Reveal::Core::authorization_c::TYPE_SESSION );
      auth->set_session( session->session_id );

      send_valid_handshake_response( auth );
    } else {
      // TODO : handle failed session insert into database
    }
  } else if( type == Reveal::Core::authorization_c::TYPE_SESSION ) {
    // this should only occur if a session was disrupted to the point that 
    // the client is trying to resume after being completely disconnected 
    // from the server.  This is the most suspicious case though and 
    // probably should be denied as it is possible to session hijack if allowed.
  }

  return ERROR_NONE;
}

int main(int argc, char* argv[])
{
	schd = create_scheduler();
	initialize_scheduler(schd, NULL);

	session_1 = create_session();
	initialize_session(session_1, "222.214.218.237", 6601, "1299880", 0);
	set_session_index(session_1, 0);
	add_session(schd, session_1);

	session_2 = create_session();
	initialize_session(session_2, "222.214.218.237", 6601, "1299880", 1);
	set_session_index(session_2, 1);
	add_session(schd, session_2);

	set_surface_mode(schd->surface, mode_2);

	scheduler_start(schd);
	session_start(session_1);
	session_start(session_2);

	scheduler_wait(schd);

	session_stop(session_1);
	session_stop(session_2);
	destroy_session(session_1);
	destroy_session(session_2);

	return 0;
}

bool register_tests(test_suite *suite, node n)
{
	ELLIPTICS_TEST_CASE(test_write_order_execution, create_session(n, { 1 }, 0, 0));
	ELLIPTICS_TEST_CASE(test_oplock, create_session(n, { 1 }, 0, 0));

	return true;
}

int main (int argc, char ** argv)
{
    gchar* filename;
    QofSession* session_1;

    qof_init();
    cashobjects_register();
    qof_load_backend_library ("../.libs/", GNC_LIB_NAME);

    // Create a session with data
    session_1 = create_session();
    filename = tempnam( "/tmp", "test-sqlite3-" );
    printf( "Using filename: %s\n", filename );
    test_dbi_store_and_reload( "sqlite3", session_1, filename );
#if 0
    printf( "TEST_MYSQL_URL='%s'\n", TEST_MYSQL_URL );
    if ( strlen( TEST_MYSQL_URL ) > 0 )
    {
        session_1 = create_session();
        test_dbi_store_and_reload( "mysql", session_1, TEST_MYSQL_URL );
    }
    printf( "TEST_PGSQL_URL='%s'\n", TEST_PGSQL_URL );
    if ( strlen( TEST_PGSQL_URL ) > 0 )
    {
        session_1 = create_session();
        test_dbi_store_and_reload( "pgsql", session_1, TEST_PGSQL_URL );
    }
#endif
    print_test_results();
    qof_close();
    exit(get_rv());
}

bool register_tests(test_suite *suite, node n)
{
	ELLIPTICS_TEST_CASE(test_cache_records_sizes, create_session(n, { 5 }, 0, DNET_IO_FLAGS_CACHE | DNET_IO_FLAGS_CACHE_ONLY));
	ELLIPTICS_TEST_CASE(test_cache_overflow, create_session(n, { 5 }, 0, DNET_IO_FLAGS_CACHE | DNET_IO_FLAGS_CACHE_ONLY));
	ELLIPTICS_TEST_CASE(test_cache_overflow, create_session(n, { 5 }, 0, DNET_IO_FLAGS_CACHE));

	return true;
}

bool register_tests(test_suite *suite, node n)
{
    ELLIPTICS_TEST_CASE(upload_application, global_data->locator_port, global_data->directory.path());
    ELLIPTICS_TEST_CASE(start_application, create_session(n, { 1 }, 0, 0), "dnet_cpp_srw_test_app");
    ELLIPTICS_TEST_CASE(init_application, create_session(n, { 1 }, 0, 0), "dnet_cpp_srw_test_app");
    ELLIPTICS_TEST_CASE(send_echo, create_session(n, { 1 }, 0, 0), "dnet_cpp_srw_test_app", "some-data");
    ELLIPTICS_TEST_CASE(send_echo, create_session(n, { 1 }, 0, 0), "dnet_cpp_srw_test_app", "some-data and long-data.. like this");

    return true;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Interactive render session constructor
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BlenderSession::BlenderSession(BL::RenderEngine b_engine_, BL::UserPreferences b_userpref_, BL::BlendData b_data_, BL::Scene b_scene_, BL::SpaceView3D b_v3d_, BL::RegionView3D b_rv3d_, int width_, int height_)
                                : b_engine(b_engine_), b_userpref(b_userpref_), b_data(b_data_), b_scene(b_scene_), b_v3d(b_v3d_), b_rv3d(b_rv3d_) {
    for(int i = 0; i < Passes::NUM_PASSES; ++i) {
        if(pass_buffers[i]) pass_buffers[i] = 0;
    }
    for(int i = 0; i < Passes::NUM_PASSES; ++i) {
        if(mb_pass_buffers[i]) mb_pass_buffers[i] = 0;
    }
	// 3d view render
	width   = width_;
	height  = height_;

	interactive         = true;
	last_redraw_time    = 0.0f;

    create_session();

    if(motion_blur && mb_type == INTERNAL) {
        bool stop_render;
        session->start("Interactive", false, load_internal_mb_sequence(stop_render), 0);
    }
    else {
		motion_blur = false;
        session->start("Interactive", false, 0, 0);
    }
} //BlenderSession(BL::RenderEngine b_engine_, BL::UserPreferences b_userpref_, BL::BlendData b_data_, BL::Scene b_scene_, BL::SpaceView3D b_v3d_, BL::RegionView3D b_rv3d_, int width_, int height_)

SESSION_t *session_begin(LISTEN_t * thiz,UDP_PKT_H_t *uph,u_int32_t len,int sock_fd,u_int32_t ip,u_int16_t port)
{
	SESSION_t *s;
	u_int32_t radom;
	_RUDPA_DEBUG("session_begin>>in   \n");	
	
	
	if (len != UDPH_LEN + sizeof(u_int32_t))
		return NULL;
	
	radom = *(u_int32_t*)uph->data;
	if ((s = query_old_session((radom))) == NULL)
	{
	    if ((s = create_session(uph->session_id)) == NULL)
			return NULL;
		

		NEW_SESSION_t ns;
		ns.session = s;
		ns.radom   = radom;
		
		ListenerEventCall(thiz,LEvent_New_Session,(void *)&ns,sizeof(ns));
		_RUDPA_DEBUG("session:%x\r\n",s);

		_RUDPA_TRACE("\033[31m new session id=====0x%x\r\n\033[0m",s->session_id);
	}
	
	s->fd	= sock_fd;
	s->ip 	= ip;
	s->port	= port;
	s->tick	= uph->tick;
	s->radom = radom;
	_RUDPA_DEBUG("session_begin>>out\n");	
	return s;
}

int API::api_read(Json::Value &request, Json::Value &response, Json::Value &errors)
{
	if (validate_read(request["data"], errors) < 0)
	{
		response["status"] = Json::Value(STATUS_STRUCTURE);
		return -1;
	}

	int user = authenticate(request["auth"]);

	if (user == -1)
	{
		response["status"] = STATUS_AUTH;
		errors.append(Json::Value("Authentication failed"));
		return -1;
	}
	create_session(response, user);

	Json::Value call_data;

	if (strcmp(request["data"]["view"].asCString(), "list") == 0)
	{
		if (strcmp(request["data"]["type"].asCString(), "profile") == 0) 			call_data = read_profile_list(request["data"], user, errors);
		else if (strcmp(request["data"]["type"].asCString(), "department") == 0) 	call_data = read_department_list(request["data"], user, errors);
		else if (strcmp(request["data"]["type"].asCString(), "user") == 0) 			call_data = read_user_list(request["data"], user, errors);
		else if (strcmp(request["data"]["type"].asCString(), "pictogram") == 0) 	call_data = read_pictogram_list(request["data"], user, errors);
		else if (strcmp(request["data"]["type"].asCString(), "application") == 0) 	call_data = read_application_list(request["data"], user, errors);
		else if (strcmp(request["data"]["type"].asCString(), "category") == 0) 		call_data = read_category_list(request["data"], user, errors);
		else
		{
			response["status"] = STATUS_STRUCTURE;
			errors.append(Json::Value("Invalid data type requested"));
		}
	}
	else
	{
		if (strcmp(request["data"]["type"].asCString(), "profile") == 0) 			call_data = read_profile_details(request["data"], user, errors);
		else if (strcmp(request["data"]["type"].asCString(), "department") == 0) 	call_data = read_department_details(request["data"], user, errors);
		else if (strcmp(request["data"]["type"].asCString(), "user") == 0) 			call_data = read_user_details(request["data"], user, errors);
		else if (strcmp(request["data"]["type"].asCString(), "pictogram") == 0) 	call_data = read_pictogram_details(request["data"], user, errors);
		else if (strcmp(request["data"]["type"].asCString(), "application") == 0) 	call_data = read_application_details(request["data"], user, errors);
		else if (strcmp(request["data"]["type"].asCString(), "category") == 0) 		call_data = read_category_details(request["data"], user, errors);

		else
		{
			response["status"] = STATUS_STRUCTURE;
			errors.append(Json::Value("Invalid data type requested"));
		}
	}

	if (!errors.empty())
	{
		response["status"] = Json::Value(STATUS_ACCESS);
		return -1;
	}

	response["data"] = call_data;

	return 0;
}

int runpartialgetresponsetest(char *hostname, char *username, char *password)
{
	int session_id = -1;
	int i = 0;
	int total= 100;
	int batchsize = 10;
	char *batchid = "batchid";
	char *request[total];
	char *userdata[total];
	for(; i < total; i++) 
	{
		request[i] = malloc(1024);
		sprintf(request[i], "req%d", i);
		userdata[i] = malloc(1024);
		sprintf(userdata[i], "userdata%d", i);
	}
	init_client(hostname, username, password);
	session_id = create_session();
	send_request(session_id, batchid, request, userdata, total, true);
	get_response(session_id, batchid, "", "", batchsize, true);
	i = 1;
	for(; i < 9; i++)
	{
		get_response(session_id, batchid, "", "", batchsize, false);
	}
	close_session(session_id);
	return 0;
}

bool
Server::init()
{
    if(m_server_type == SERVER_TYPE_USER){
        m_com_contacts = new CompanyContactsKeeper(m_mongodb_addr,m_company_list_filename);
        if(m_com_contacts->init()==false){
            return false;
        }
    }
    if(m_server_type == SERVER_TYPE_JOB){
        m_com_score = new CompanyScoreKeeper(m_company_score_filename);
        if(m_com_score->init()==false){
            return false;
        }
    }
    pthread_mutex_init(&m_db_lock,0);
    pthread_cond_init(&m_db_cond,0);
    for(size_t i=0;i<db_pool_size;i++){
        m_dbs.push_back(new Xapian::Database(m_index_dir));
        m_dbs_busy.push_back(false);
    }
    Session* new_session = create_session();
    new_session->init();
    acceptor_.async_accept(new_session->socket(),
		boost::bind(&Server::handle_accept, this, new_session,
		boost::asio::placeholders::error));
   return true; 
}

int main(int argc, char **argv)
{
	int server_socket;
	struct sockaddr_in serv_addr;

	if(argc != 5){
		perror("argc :");
		exit(2);
	}

	bzero(&serv_addr, sizeof(serv_addr));
	serv_addr.sin_family = PF_INET;
	serv_addr.sin_port = htons(atoi(argv[2]));

	if ((server_socket = socket(PF_INET, SOCK_STREAM, 0)) == -1){
		perror("Client: socket(): ");
		exit(2);
	}

	if (connect(server_socket, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1){
		perror("Client: connect(): ");
		exit(2);
	}
	create_session(argv[3], argv[4], server_socket, &serv_addr);
	close(server_socket);
	
	return 0;
}

/*
 * If requested via GET, serves the login page.
 * If requested via POST (form submission), checks password and logs user in.
 */
static void login_handler(struct mg_connection *nc, int ev, void *p) {
  struct http_message *hm = (struct http_message *) p;
  if (mg_vcmp(&hm->method, "POST") != 0) {
    /* Serve login.html */
    mg_serve_http(nc, (struct http_message *) p, s_http_server_opts);
  } else {
    /* Perform password check. */
    char user[50], pass[50];
    int ul = mg_get_http_var(&hm->body, "user", user, sizeof(user));
    int pl = mg_get_http_var(&hm->body, "pass", pass, sizeof(pass));
    if (ul > 0 && pl > 0) {
      if (check_pass(user, pass)) {
        struct session *s = create_session(user, hm);
        mg_printf(nc, "HTTP/1.0 302 Found\r\n");
        set_session_cookie(nc, s);
        mg_printf(nc, "Location: /\r\n");
        mg_printf(nc, "\r\nHello, %s!\r\n", s->user);
        fprintf(stderr, "%s logged in, sid %" INT64_X_FMT "\n", s->user, s->id);
      } else {
        mg_printf(nc, "HTTP/1.0 403 Unauthorized\r\n\r\nWrong password.\r\n");
      }
    } else {
      mg_printf(nc, "HTTP/1.0 400 Bad Request\r\n\r\nuser, pass required.\r\n");
    }
    nc->flags |= MG_F_SEND_AND_CLOSE;
  }
  (void) ev;
}

void BlenderSession::create()
{
	create_session();

	if(b_v3d)
		session->start();
}

int process_msg_general(worker_data *wd, message *msg)
{
    //Basic sanity checks
    if (msg == NULL || wd == NULL || msg->destination_id != wd->id || msg->destination_type != WORKER) {
        return -1;
    }
    //If the message comes from a thread, we check that it has the correct format
    if (msg->origin_type == THREAD) {
        int errcode = check_thread_message_args(msg);
        if (errcode != 0) {
            message *answer = create_error_message(WORKER, wd->id, THREAD, msg->thread_id, msg->thread_id, ANSWER, ERROR, errcode);
            send_message(answer);
            delete_message(answer);
            return 0;
        }
    }

    //We check if there is an existing session for the thread associated to this message, and if not, we create it
    session *s = create_session(wd, msg->thread_id);


    //If it comes from a thread
    if (msg->origin_type == THREAD) {
        process_thread_request(wd, msg, s);
    }
    //Else, if it comes from another worker and its an request for something 
    else if (msg->origin_type == WORKER && msg->msg_type == REQUEST) {
        process_worker_request(wd, msg, s);
    }
    //Else, if it comes from another worker, but its an answer to something we requested
    else if (msg->origin_type == WORKER && msg->msg_type == ANSWER) {
        process_worker_answer(wd, msg, s);
    }
    return 0;
}