ALWAYS_INLINE Object makeEventHttpRequestObject(evhttp_request_t *request) {
Object http_request = ObjectData::newInstance(Unit::lookupClass(String("EventHttpRequest").get()));
Resource resource = Resource(NEWOBJ(EventHttpRequestResourceData(http_request.get())));
SET_RESOURCE(http_request, resource, s_event_http_request);
EventHttpRequestResourceData *resource_data = FETCH_RESOURCE(http_request, EventHttpRequestResourceData, s_event_http_request);
evhttp_request_own(request);
resource_data->setInternalResourceData((void *) request);
resource_data->isInternal = true;
return http_request;
}
static void HHVM_METHOD(EventHttpRequest, __construct, const Object &callback, const Variant &data) {
evhttp_request_t *http_request;
Resource resource = Resource(NEWOBJ(EventHttpRequestResourceData(this_.get())));
SET_RESOURCE(this_, resource, s_event_http_request);
EventHttpRequestResourceData *resource_data = FETCH_RESOURCE(this_, EventHttpRequestResourceData, s_event_http_request);
http_request = evhttp_request_new(event_http_request_cb, (void *) resource_data);
evhttp_request_own(http_request);
resource_data->setInternalResourceData((void *) http_request);
callback.get()->incRefCount();
resource_data->setCallback(callback.get());
resource_data->setCallbackArg(data);
}
static void rpc_grneral_request(char *ip, int port, const char *rpcname,
void *req, marshal_func req_marshal,
void *resp, unmarshal_func resp_unmarshal)
{
struct evhttp_connection *evcon =
connection_pool_get_or_create_conn(conn_pool, ip, port);
struct evhttp_request *evreq =
evhttp_request_new(rpc_rpc_grneral_requestuest_cb, NULL);
evhttp_request_own(evreq); // this means that I should free it my self
req_marshal(evreq->output_buffer, req);
if (evhttp_make_request(evcon, evreq, EVHTTP_REQ_POST, rpcname))
logging(LOG_ERROR, "error on make_request");
event_dispatch();//TODO
if (resp_unmarshal(resp, evreq->input_buffer)) {
logging(LOG_ERROR, "error on statfs_response_unmarshal");
}
connection_pool_insert(conn_pool, ip, port, evcon);
evhttp_request_free(evreq);
}
static void event_http_request_cb(evhttp_request_t *request, void *data) {
EventHttpRequestResourceData *resource_data = (EventHttpRequestResourceData *) data;
evhttp_request_own((evhttp_request_t *) resource_data->getInternalResourceData());
vm_call_user_func(Object(resource_data->getCallback()), make_packed_array(Object(resource_data->getObjectData()), resource_data->getCallbackArg()));
}
virtual void httpRecvReq(struct evhttp_request *req) {
std::cout << "---- received:" << std::endl;
if (evhttp_request_get_command(req) != EVHTTP_REQ_POST)
return;
evhttp_request_own(req);
struct evkeyval *header;
struct evkeyvalq *headers;
headers = evhttp_request_get_input_headers(req);
for (header = headers->tqh_first; header;
header = header->next.tqe_next) {
// std::cout << header->key << ": " << header->value << std::endl;
}
std::string content;
struct evbuffer *buf;
buf = evhttp_request_get_input_buffer(req);
while (evbuffer_get_length(buf)) {
int n;
char cbuf[128];
n = evbuffer_remove(buf, cbuf, sizeof(buf)-1);
if (n > 0) {
content.append(cbuf, n);
}
}
uscxml::Data jsonReq = uscxml::Data::fromJSON(content);
std::cout << jsonReq << std::endl;
// is this a load request?
if (jsonReq.compound.find("load") != jsonReq.compound.end()) {
std::string filename = jsonReq.compound["load"].atom;
std::cout << "Starting Interpreter with " << filename << std::endl;
uscxml::Interpreter* interpreter = uscxml::Interpreter::fromURI(filename);
if (interpreter) {
std::string token = uscxml::toStr(lastToken++);
assert(_interpreters.find(token) == _interpreters.end());
interpreter->setName(token);
interpreter->addMonitor(this);
interpreter->start();
_interpreters[token] = std::make_pair(interpreter, req);
}
return;
}
if(jsonReq.compound.find("event") != jsonReq.compound.end()) {
assert(jsonReq.compound["event"].compound.find("sessionToken") != jsonReq.compound["event"].compound.end());
std::string token = jsonReq.compound["event"].compound["sessionToken"].atom;
assert(_interpreters.find(token) != _interpreters.end());
uscxml::Event event;
event.type = uscxml::Event::INTERNAL;
event.name = jsonReq.compound["event"].compound["name"].atom;
std::cout << "Sending event " << event << std::endl;
// evhttp_request_free(_interpreters[token].second);
_interpreters[token].second = req;
_interpreters[token].first->receive(event);
}
}
