/** Object **/
void HttpRespond::init(){
ASSIGN_POINTER(m_header_tb, SafeNew<Hash>());
ASSIGN_POINTER(m_cookie_tb, SafeNew<Hash>());
ASSIGN_POINTER(m_content, SafeNew<Bytes>());
RETAIN_POINTER(m_requestor);
Super::init();
}
/** Service **/
bool CoroutineService::on_load(){
if(!Super::on_load()) return false;
OPH();
ASSIGN_POINTER(m_name, STR("CoroutineService"));
ASSIGN_POINTER(m_command_desc_table, SafeNew<Hash>());
ASSIGN_POINTER(m_sleeper_table, SafeNew<Hash>());
ASSIGN_POINTER(m_cr_pool, SafeNew<CoroutinePool>());
register_command();
return true;
}
bool HttpRespond::_parse_mime(){
// check
if(!m_content || !m_header_tb){
return true;
}
String* content_type =static_cast< String* >(m_header_tb->get("Content-Type"));
if(!content_type){
return true;
}
// parse
if(content_type->is("multipart/form-data")){
WARN("parse mime failed, multipart/form-data not support");
return false;
}
else if(content_type->is("application/x-www-form-urlencoded")){
ASSIGN_POINTER(m_post_tb, SafeNew<Hash>());
if(Url::ParseQuery(String::New(m_content->c_str(), m_content->size()), m_post_tb)){
return true;
}
else{
WARN("parse mime failed, application/x-www-form-urlencoded invalid");
return false;
}
}
else{
return true;
}
}
void Hash::set(Object* key, Object* val){
if(!key) return;
if(!m_slot_count){
_try_rehash();
}
const int64_t slot =_key_to_slot(key);
// try find exist
PNODE node =m_pSlotArray[slot];
while(node){
if(Object::Equals(key, node->key)){
ASSIGN_POINTER(node->value, val);
return;
}
node =node->next;
}
// try rehash
_try_rehash();
// new node
PNODE new_node=reinterpret_cast<PNODE>(ALLOCATE(sizeof(NODE)));
new_node->prev =0;
if(m_pSlotArray[slot]) m_pSlotArray[slot]->prev =new_node;
new_node->next =m_pSlotArray[slot];
m_pSlotArray[slot] =new_node;
m_item_count +=1;
new_node->key =key->clone();
if(new_node->key) new_node->key->retain();
new_node->value =val;
if(new_node->value) new_node->value->retain();
}
void ApplicationBase::setDataPath(String* path){
// root
ASSIGN_POINTER(m_data_path, path);
// bin & data
if(m_data_path){
ASSIGN_POINTER(m_root_path, FileSystem::Join(m_data_path, STR("../")));
ASSIGN_POINTER(m_bin_path, FileSystem::Join(m_root_path, STR("bin/")));
INFO("data path is '%s'", m_data_path->c_str());
INFO("root path is '%s'", m_root_path->c_str());
INFO("bin path is '%s'", m_bin_path->c_str());
}
else{
CLEAN_POINTER(m_root_path);
CLEAN_POINTER(m_bin_path);
}
}
/** query **/
void Logger::setName(String* name){
ASSIGN_POINTER(m_szName, name);
if(m_file){
fclose(m_file);
m_file =0;
m_file_open_time =0;
}
if(m_szName){
_open_file();
}
}
bool TcpListener::listen(const char* path){
if(!path || strlen(path)==0){
return false;
}
ASSIGN_POINTER(m_path, STR(path));
CHECK_RETURN_VALUE(m_path, false);
struct sockaddr_un sun;
memset(&sun, 0, sizeof(sun));
sun.sun_family =AF_UNIX;
strcpy(sun.sun_path, m_path->c_str());
return _listen(AF_UNIX, reinterpret_cast< struct sockaddr* >(&sun), SUN_LEN(&sun));
}
int64_t Coroutine::_resume(Object* param){
#ifdef VALGRIND_CHECK_ENABLE
if(m_stack == 0){
m_stack =reinterpret_cast< char* >(ALLOCATE(CoroutinePool::MAIN_STACK_SIZE));
m_stack_size =CoroutinePool::MAIN_STACK_SIZE;
if(0 != getcontext(&m_ctx)){
FATAL("fail to %s, %s", get_last_error_desc());
return -ErrorCode::SYSTEM_ERROR;
}
m_ctx.uc_stack.ss_sp =m_stack;
m_ctx.uc_stack.ss_size =m_stack_size;
m_ctx.uc_stack.ss_flags =0;
m_ctx.uc_link =m_coroutine_pool->getMainContext();
makecontext(&m_ctx, (void(*)())(_entry), 0);
_valgrind_register();
}
#else
if(m_stack == 0){
if(0 != getcontext(&m_ctx)){
FATAL("fail to %s, %s", get_last_error_desc());
return -ErrorCode::SYSTEM_ERROR;
}
m_stack_size =0;
m_ctx.uc_stack.ss_sp =m_coroutine_pool->getMainStack();
m_ctx.uc_stack.ss_size =m_coroutine_pool->getMainStackSize();
m_ctx.uc_stack.ss_flags =0;
m_ctx.uc_link =m_coroutine_pool->getMainContext();
makecontext(&m_ctx, (void(*)())(_entry), 0);
}
else{
memcpy(m_coroutine_pool->getMainStackHighAddr() - m_stack_size, m_stack, m_stack_size);
}
#endif
// set status
m_status =STATUS_RUNNING;
g_running =this;
ASSIGN_POINTER(m_resume_param, param);
// swap context
if(0 != swapcontext(m_coroutine_pool->getMainContext(), &m_ctx)){
FATAL("fail to %s, %s", get_last_error_desc());
return -ErrorCode::SYSTEM_ERROR;
}
return m_status;
}
/** name & field **/
void ClassInfo::setName(String* name) {
ASSIGN_POINTER(m_name, name);
}
void HttpRespond::setMsg(String* msg){
ASSIGN_POINTER(m_msg, msg);
}
/** Service **/
bool CallbackService::on_load(){
if(!Super::on_load()) return false;
ASSIGN_POINTER(m_command_desc_table, SafeNew<Hash>());
register_command();
return true;
}
/** Object **/
void ClassInfo::init() {
Super::init();
ASSIGN_POINTER(m_FieldInfo, SafeNew<Array>());
}
/** Object **/
void Actor::init(){
Super::init();
ASSIGN_POINTER(m_observer_manager, SafeNew<Hash>());
ASSIGN_POINTER(m_component_manager, SafeNew<Hash>());
}
/* Object */
void CommandService::init() {
Super::init();
ASSIGN_POINTER(m_queue_tb, SafeNew<Hash>());
ASSIGN_POINTER(m_rpc_tb, SafeNew<Hash>());
}
/** Object **/
void BytesChannel::init(){
Super::init();
_create_fd();
ASSIGN_POINTER(m_cycle_buffer, SafeNew<CycleBuffer>());
}
/** associate command **/
void RpcInfo::setCommand(Command* cmd) {
ASSIGN_POINTER(m_command, cmd);
}
/** set **/
void RpcInfo::set(const int64_t id, Command* cmd, const int64_t expire_time) {
ASSERT(m_id == 0);
m_id =id;
ASSIGN_POINTER(m_command, cmd);
m_expire_time =expire_time;
}
/** Service **/
bool LogService::on_load(){
if(!Super::on_load()) return false;
ASSIGN_POINTER(m_name, STR("LogService"));
ASSIGN_POINTER(m_logger_table, SafeNew<Hash>());
return _load("../data/startup/log_service.lua");
}
bool Url::_build(String* protocol, String* auth, String* host, String* path, String* query_string, Hash* query, String* fragment){
// clean
clean();
// check
if(path && path->size() && !path->hasPrefix("/")){
return false;
}
// make url
BinaryCoder<1024> coder;
if(protocol && protocol->size()){
ASSIGN_POINTER(m_protocol, protocol);
coder.append(protocol);
coder.append("://", 3);
}
if(auth && auth->size()){
ASSIGN_POINTER(m_auth, auth);
coder.append(auth);
coder.append("@", 1);
}
if(host && host->size()){
ASSIGN_POINTER(m_host, host);
coder.append(host);
}
if(path && path->size()){
ASSIGN_POINTER(m_path, path);
coder.append(path);
}
if(query_string && query_string->size()){
ASSIGN_POINTER(m_query_string, query_string);
ASSIGN_POINTER(m_query, SafeNew<Hash>());
if(!ParseQuery(m_query_string, m_query)){
clean();
return false;
}
coder.append("?", 1);
coder.append(m_query_string);
}
else if(query && query->size()){
ASSIGN_POINTER(m_query, query);
// make query string
BinaryCoder<1024> sub_coder;
HashIterator* it =static_cast< HashIterator* >(query->iterator());
while(it->next()){
String* key =static_cast< String* >(it->getKey());
String* val =static_cast< String* >(it->getValue());
if(sub_coder.size() > 0){
sub_coder.append("&", 1);
}
sub_coder.append(UrlEncode::Encode(key));
sub_coder.append("=", 1);
sub_coder.append(UrlEncode::Encode(val));
}
// set
ASSERT(sub_coder.size());
ASSIGN_POINTER(m_query_string, String::New(sub_coder.c_str(), sub_coder.size()));
coder.append("?", 1);
coder.append(m_query_string);
}
if(fragment && fragment->size()){
ASSIGN_POINTER(m_fragment, fragment);
coder.append("#", 1);
coder.append(fragment);
}
ASSIGN_POINTER(m_url, String::New(coder.c_str(), coder.size()));
return true;
}
/** head line **/
void HttpRespond::setVersion(String* version){
ASSIGN_POINTER(m_version, version);
}
/** modify **/
bool Url::parse(String* url){
// clean
clean();
// check
if(!url){
return false;
}
// prepare sz
const char* sz =url->c_str();
// puts(sz);
// protocol
const char* cursor =strstr(sz, "://");
int64_t pos =(cursor ? (cursor-sz) : -1);
if(pos == 0){
ERROR("fail to call %s, len(protocol) can't be 0");
return false;
}
else if(pos > 0){
ASSIGN_POINTER(m_protocol, String::New(sz, pos));
sz =cursor + 3;
}
// auth
cursor =strchr(sz, '@');
pos =(cursor ? (cursor-sz) : -1);
if(pos == 0){
CLEAN_POINTER(m_protocol);
ERROR("fail to call %s, len(auth) can't be 0");
return false;
}
else if(pos > 0){
ASSIGN_POINTER(m_auth, String::New(sz, pos));
sz =cursor + 1;
}
// host
const char* szbeg =sz;
while(const char ch =*sz){
if(ch=='/' || ch=='?' || ch=='#'){
break;
}
++sz;
}
if(sz > szbeg){
ASSIGN_POINTER(m_host, String::New(szbeg, sz-szbeg));
}
// path
if(*sz == '/'){
const char* szbeg =sz++;
while(const char ch =*sz){
if(ch=='?' || ch=='#'){
break;
}
++sz;
}
ASSIGN_POINTER(m_path, String::New(szbeg, sz-szbeg));
}
// query
if(*sz == '?'){
const char* szbeg =++sz;
while(const char ch =*sz){
if(ch == '#'){
break;
}
++sz;
}
if(sz > szbeg){
ASSIGN_POINTER(m_query_string, String::New(szbeg, sz-szbeg));
ASSIGN_POINTER(m_query, SafeNew<Hash>());
if(!ParseQuery(m_query_string, m_query)){
clean();
return false;
}
}
else{
ASSIGN_POINTER(m_query_string, String::New(szbeg, sz-szbeg));
}
}
// fragment
if(*sz == '#'){
ASSIGN_POINTER(m_fragment, String::New(sz+1));
}
// url
ASSIGN_POINTER(m_url, url);
return true;
}
/** Object **/
void CoroutinePool::init(){
Super::init();
ASSIGN_POINTER(m_active_coroutine_table, SafeNew<Hash>());
ASSIGN_POINTER(m_idle_coroutine_list, SafeNew<Array>());
}
/** task **/
void Coroutine::setTask(PFN_COROUTINE_TASK pfn, Object* arg){
m_task =pfn;
ASSIGN_POINTER(m_arg, arg);
}
/** Object **/
void ObjectFactory::init(){
Super::init();
ASSIGN_POINTER(m_class_info_tb, SafeNew<Hash>());
}
/* Service */
bool CService::load_module(const int64_t id, const char* path){
if(!Super::load_module(id, path)) return false;
if(!path) return false;
m_id =id;
// load dll
m_dl =::dlopen(path, RTLD_NOW | RTLD_GLOBAL);
if(m_dl == 0){
const char* err =::dlerror();
ERROR("fail to call dlopen <%s>, %s", path, err ? err : "no error");
return false;
}
// object pool manager
OPH();
// set path
String* p =String::NewString(path);
ASSIGN_POINTER(m_path, p);
// get name
{
const char* (*fn_get_name)() =(const char* (*)())::dlsym(m_dl, "get_name");
if(!fn_get_name){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, get_name>, %s", path, err ? err : "no error");
unload_module();
return false;
}
const char* name =fn_get_name();
if(!name) name ="unnamed";
CLEAN_POINTER(m_name);
m_name =String::NewString(name);
m_name->retain();
}
// get desc
{
const char* (*fn_get_desc)() =(const char* (*)())::dlsym(m_dl, "get_desc");
if(!fn_get_desc){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, get_desc>, %s", path, err ? err : "no error");
unload_module();
return false;
}
const char* desc =fn_get_desc();
if(!desc) desc ="";
CLEAN_POINTER(m_desc);
m_desc =String::NewString(desc);
m_desc->retain();
}
// get on_load
{
m_on_load =(PFN_ON_LOAD)::dlsym(m_dl, "on_load");
if(!m_on_load){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, on_load>, %s", path, err ? err : "no error");
unload_module();
return false;
}
}
// get on_update
{
m_on_update =(PFN_ON_UPDATE)::dlsym(m_dl, "on_update");
if(!m_on_update){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, on_update>, %s", path, err ? err : "no error");
unload_module();
return false;
}
}
// get on_start_command
{
m_on_start_command =(PFN_ON_START_COMMAND)::dlsym(m_dl, "on_start_command");
if(!m_on_start_command){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, on_start_command>, %s", path, err ? err : "no error");
unload_module();
return false;
}
}
// get on_unload
{
m_on_unload =(PFN_ON_UNLOAD)::dlsym(m_dl, "on_unload");
if(!m_on_unload){
const char* err =::dlerror();
ERROR("fail to call dlsym <%s, on_unload>, %s", path, err ? err : "no error");
unload_module();
return false;
}
}
return true;
}
/** Self **/
void HashIterator::bind(Hash* hash){
ASSIGN_POINTER(m_hash, hash);
m_index =-1;
m_cursor =0;
}
void BytesChannel::setEventCallback(PFN_ON_EVENT pfn, Object* ctx){
std::lock_guard<std::mutex> guard(m_mutex);
m_on_event =pfn;
ASSIGN_POINTER(m_ctx, ctx);
}
