int64_t CallbackService::on_start_command(Command* command){
Super::on_start_command(command);
PACKET packet =command->getPacket();
const int64_t who =command->getWho();
const int64_t req_cmd =command->getRequestCommand();
if(CallbackCommandDesc* desc =static_cast< CallbackCommandDesc* >(m_command_desc_table->get(req_cmd))){
//// prepare
Bytes* body =command->getBody();
const int64_t grp_id =m_protocol_group_id;
const int64_t res_cmd =desc->getRespondCommand();
CallbackCommandDesc::PFN_CALLBACK callback =desc->getCallback();
//// try code as protocol
if(desc->isUseProtocol()){
ProtocolManager* pm =ProtocolManager::Instance();
// request
if(!(packet.option & OPT_BODY_IS_OBJECT_POINTER)){
ProtocolBase* req =pm->createProtocol(grp_id, req_cmd);
if(!req){
ERROR("service %s(%lld) who %lld fail to start command %lld, create request group %lld protocol %lld error", name(), (long long)m_id, (long long)who, (long long)req_cmd, (long long)grp_id, (long long)req_cmd);
return Command::STATE_ERROR;
}
if(!req->fromBytes(body)){
ERROR("service %s(%lld) who %lld fail to start command %lld, decode request group %lld protocol %lld error", name(), (long long)m_id, (long long)who, (long long)req_cmd, (long long)grp_id, (long long)req_cmd);
return Command::STATE_ERROR;
}
command->setRequest(req);
}
// respond
if(res_cmd > 0){
ProtocolBase* res =pm->createProtocol(grp_id, res_cmd);
if(!res){
ERROR("service %s(%lld) who %lld fail to start command %lld, create respond group %lld protocol %lld error", name(), (long long)m_id, (long long)who, (long long)req_cmd, (long long)grp_id, (long long)res_cmd);
return Command::STATE_ERROR;
}
command->setRespond(res);
command->setRespondCommand(res->id());
}
}
//// callback
return callback(command);
}
else{
ERROR("service %s(%lld) who %lld fail to start command %lld, command not found", name(), (long long)m_id, (long long)who, (long long)req_cmd);
return Command::STATE_ERROR;
}
}
PreferencesAccounts::PreferencesAccounts()
: BView("Accounts", B_WILL_DRAW)
{
fListView = new BListView("accountsListView");
fListView->SetInvocationMessage(new BMessage(kEditAccount));
fListView->SetSelectionMessage(new BMessage(kSelect));
BScrollView* scrollView = new BScrollView("scrollView", fListView,
B_WILL_DRAW, false, true);
ProtocolManager* pm = ProtocolManager::Get();
fProtosMenu = new BPopUpMenu(NULL, true);
for (uint32 i = 0; i < pm->CountProtocolAddOns(); i++) {
CayaProtocolAddOn* addOn = pm->ProtocolAddOnAt(i);
ProtocolSettings* settings = new ProtocolSettings(addOn);
// Add accounts to list view
_LoadListView(settings);
// Add menu items
BMessage* msg = new BMessage(kAddAccount);
msg->AddPointer("settings", settings);
BitmapMenuItem* item = new BitmapMenuItem(
addOn->FriendlySignature(), msg, addOn->Icon());
fProtosMenu->AddItem(item);
}
ToolButton* proto = new ToolButton("+", NULL);
proto->SetMenu(fProtosMenu);
fDelButton = new ToolButton("-", new BMessage(kDelAccount));
fEditButton = new ToolButton("Edit...", new BMessage(kEditAccount));
fDelButton->SetEnabled(false);
fEditButton->SetEnabled(false);
const float spacing = be_control_look->DefaultItemSpacing();
SetLayout(new BGroupLayout(B_HORIZONTAL, spacing));
AddChild(BGroupLayoutBuilder(B_VERTICAL)
.Add(scrollView)
.AddGroup(B_HORIZONTAL, spacing)
.Add(proto)
.Add(fDelButton)
.AddGlue()
.Add(fEditButton)
.End()
.SetInsets(spacing, spacing, spacing, spacing)
);
}
int64_t CoroutineService::on_start_command(Command* command){
Super::on_start_command(command);
PACKET packet =command->getPacket();
const int64_t grp_id =m_protocol_group_id;
const int64_t who =command->getWho();
const int64_t req_cmd =command->getRequestCommand();
if(CoroutineCommandDesc* desc =static_cast< CoroutineCommandDesc* >(m_command_desc_table->get(req_cmd))){
//// preprocess command
const int64_t res_cmd =desc->getRespondCommand();
Bytes* body =command->getBody();
ProtocolManager* pm =ProtocolManager::Instance();
//// try code as protocol
if(desc->isUseProtocol()){
// request
if(!(packet.option & OPT_BODY_IS_OBJECT_POINTER)){
ProtocolBase* req =pm->createProtocol(grp_id, req_cmd);
if(!req){
ERROR("service %s(%lld) who %lld fail to start command %lld, create request group %lld protocol %lld error", name(), (long long)m_id, (long long)who, (long long)req_cmd, (long long)grp_id, (long long)req_cmd);
return Command::STATE_ERROR;
}
if(!req->fromBytes(body)){
ERROR("service %s(%lld) who %lld fail to start command %lld, unmarsh request group %lld protocol %lld error", name(), (long long)m_id, (long long)who, (long long)req_cmd, (long long)grp_id, (long long)req_cmd);
return Command::STATE_ERROR;
}
command->setRequest(req);
}
// respond
if(res_cmd > 0){
ProtocolBase* res =pm->createProtocol(grp_id, res_cmd);
if(!res){
ERROR("service %s(%lld) who %lld fail to start command %lld, create respond group %lld protocol %lld error", name(), (long long)m_id, (long long)who, (long long)req_cmd, (long long)grp_id, (long long)res_cmd);
return Command::STATE_ERROR;
}
command->setRespond(res);
command->setRespondCommand(res->id());
}
}
//// go coroutine
int64_t cr_new_id=0;
const int64_t result =m_cr_pool->go(desc->getCallback(), command, cr_new_id);
if(result >= 0){
if(result == Coroutine::STATUS_IDLE){
return Command::STATE_COMPLETE;
}
else if(result == Coroutine::STATUS_WAITING){
return cr_new_id;
}
else{
return Command::STATE_ERROR;
}
}
else{
ERROR("service %s(%lld) who %lld fail to start command %lld, error code %lld", name(), (long long)m_id, (long long)who, (long long)req_cmd, (long long)-result);
return Command::STATE_ERROR;
}
}
else{
ERROR("service %s(%lld) who %lld fail to start command %lld, not config", name(), (long long)m_id, (long long)packet.who, (long long)req_cmd);
return core::Command::STATE_ERROR;
}
}
int run_haggle()
{
srand(time(NULL));
#ifdef ENABLE_DEBUG_MANAGER
DebugManager *db = NULL;
#endif
ApplicationManager *am = NULL;
DataManager *dm = NULL;
// SW: START: SendPriorityManager
SendPriorityManager *spm = NULL;
// SW: END: SendPriorityManager
NodeManager *nm = NULL;
ProtocolManager *pm = NULL;
ForwardingManager *fm = NULL;
SecurityManager *sm = NULL;
ConnectivityManager *cm = NULL;
LossEstimateManager *lm = NULL;
NetworkCodingManager* networkCodingManager = NULL;
FragmentationManager* fragmentationManager = NULL;
//JM
ReplicationManager *replicationManager = NULL;
BenchmarkManager *bm = NULL;
ResourceManager *rm = NULL;
// SW: START: interest manager
InterestManager *im = NULL;
// SW: END: interest manager
ProtocolSocket *p = NULL;
#ifdef OS_WINDOWS_MOBILE
// For testing we force the deletion of the data store
//recreateDataStore = true;
#endif
int retval = EXIT_FAILURE;
#if defined(OS_ANDROID)
//mallopt(-1, -1); // MOS - avoid trimming
#elif defined(OS_LINUX)
mallopt(M_TRIM_THRESHOLD, -1); // MOS - avoid trimming
#endif
xmlInitParser(); // MOS - this need to be called here for thread-safe libxml use
#ifdef DEBUG
Trace::trace.enableFileTrace();
#endif
HAGGLE_LOG("\n\n****************** HAGGLE STARTUP *********************\n\n");
if (!create_path(HAGGLE_DEFAULT_STORAGE_PATH)) {
HAGGLE_ERR("Could not create Haggle storage path : %s\n", HAGGLE_DEFAULT_STORAGE_PATH);
return -1;
}
retval = write_pid_file(getpid());
if (retval != HAGGLE_PROCESS_NO_ERROR) {
switch (retval) {
case HAGGLE_PROCESS_BAD_PID:
HAGGLE_ERR("Cannot read PID file %s.\n", PID_FILE.c_str());
break;
case HAGGLE_PROCESS_CANNOT_WRITE_PID:
HAGGLE_ERR("Cannot write PID file %s\n", PID_FILE.c_str());
break;
case HAGGLE_PROCESS_ALREADY_RUNNING:
HAGGLE_ERR("PID file %s indicates that Haggle is already running.\n", PID_FILE.c_str());
break;
default:
HAGGLE_ERR("Unknown PID file error\n");
}
shouldCleanupPidFile = false;
return -1;
}
#if defined(OS_UNIX) && !defined(OS_ANDROID)
setrawtty();
#endif
/* Seed the random number generator */
prng_init();
// SW: START CONFIG PATH (instead of hardcoded ~/.Haggle/config.xml),
if (useMemoryDB) {
kernel = new HaggleKernel(configFile, new MemoryDataStore(recreateDataStore));
}
else {
kernel = new HaggleKernel(configFile, new SQLDataStore(recreateDataStore));
}
// SW: END CONFIG PATH.
if (!kernel || !kernel->init()) {
fprintf(stderr, "Kernel initialization error!\n");
return -1;
}
// Build a Haggle configuration
am = new ApplicationManager(kernel);
if (!am || !am->init()) {
HAGGLE_ERR("Could not initialize application manager\n");
goto finish;
}
dm = new DataManager(kernel, setCreateTimeOnBloomfilterUpdate);
if (!dm || !dm->init()) {
HAGGLE_ERR("Could not initialize data manager\n");
goto finish;
}
// SW: START: SendPriorityManager
spm = new SendPriorityManager(kernel);
if (!spm || !spm->init()) {
HAGGLE_ERR("Could not initialize send priority manager\n");
goto finish;
}
// SW: END: SendPriorityManager
nm = new NodeManager(kernel);
if (!nm || !nm->init()) {
HAGGLE_ERR("Could not initialize node manager\n");
goto finish;
}
pm = new ProtocolManager(kernel);
if (!pm || !pm->init()) {
HAGGLE_ERR("Could not initialize protocol manager\n");
goto finish;
}
fm = new ForwardingManager(kernel);
if (!fm || !fm->init()) {
HAGGLE_ERR("Could not initialize forwarding manager\n");
goto finish;
}
sm = new SecurityManager(kernel, securityLevel);
if (!sm || !sm->init()) {
HAGGLE_ERR("Could not initialize security manager\n");
goto finish;
}
fragmentationManager = new FragmentationManager(kernel);
if(!fragmentationManager || !fragmentationManager->init()) {
HAGGLE_ERR("Could not initialize fragmentationManager\n");
goto finish;
}
networkCodingManager = new NetworkCodingManager(kernel);
if(!networkCodingManager || !networkCodingManager->init()) {
HAGGLE_ERR("Could not initialize networkCodingManager \n");
goto finish;
}
//JM
replicationManager = new ReplicationManager(kernel);
if (!replicationManager || !replicationManager->init()) {
HAGGLE_ERR("Could not initialize replication manager\n");
goto finish;
}
lm = new LossEstimateManager(kernel);
if(!lm || !lm->init()){
HAGGLE_ERR("Could not initialize LossEstimateManager \n");
goto finish;
}
#ifdef USE_UNIX_APPLICATION_SOCKET
p = new ProtocolLOCAL(kernel->getStoragePath() + "/" + HAGGLE_LOCAL_SOCKET, pm);
if (!p || !p->init()) {
HAGGLE_ERR("Could not initialize LOCAL protocol\n");
goto finish;
}
p->setFlag(PROT_FLAG_APPLICATION);
p->registerWithManager();
#endif
p = new ProtocolUDP("127.0.0.1", HAGGLE_SERVICE_DEFAULT_PORT, pm);
/* Add ConnectivityManager last since it will start to
* discover interfaces and generate events. At that
* point the other managers should already be
* running. */
if (!p || !p->init()) {
HAGGLE_ERR("Could not initialize UDP Application protocol\n");
goto finish;
}
p->setFlag(PROT_FLAG_APPLICATION);
p->registerWithManager();
// SW: start interest manager
im = new InterestManager(kernel);
if (!im || !im->init()) {
HAGGLE_ERR("Could not initialize interest manager\n");
goto finish;
}
// SW: end interest manager
/* MOS - disable resource mananager due
high cpu utilization bug on Android
rm = new ResourceManager(kernel);
if (!rm || !rm->init()) {
HAGGLE_ERR("Could not initialize resource manager\n");
goto finish;
}
*/
if (!isBenchmarking) {
cm = new ConnectivityManager(kernel);
if (!cm || !cm->init()) {
HAGGLE_ERR("Could not initialize connectivity manager\n");
goto finish;
}
} else {
bm = new BenchmarkManager(kernel, Benchmark_DataObjects_Attr, Benchmark_Nodes_Attr, Benchmark_Attr_Num, Benchmark_DataObjects_Num, Benchmark_Test_Num);
if (!bm || !bm->init()) {
HAGGLE_ERR("Could not initialize benchmark manager\n");
goto finish;
}
}
#if defined(ENABLE_DEBUG_MANAGER)
// It seems as if there can be only one accept() per
// thread... we need to make the DebugManager register
// protocol or something with the ProtocolTCPServer
// somehow
db = new DebugManager(kernel, runAsInteractive);
if (!db || !db->init()) {
HAGGLE_ERR("Could not initialize debug manager\n");
/* Treat as non critical error. */
}
#endif
HAGGLE_DBG("Starting Haggle...\n");
#ifdef OS_WINDOWS_MOBILE
if (platform_type(current_platform()) == platform_windows_mobile_professional)
tray_notification_add(g_hInstance, kernel);
#endif
kernel->run();
if(kernel->hasFatalError()) retval = EXIT_FAILURE;
else retval = EXIT_SUCCESS;
HAGGLE_DBG("Haggle finished...\n");
finish:
if (bm)
delete bm;
if (lm)
delete lm;
if (fragmentationManager) {
delete fragmentationManager;
fragmentationManager = NULL;
}
if (networkCodingManager)
delete networkCodingManager;
//JM
if (replicationManager)
delete replicationManager;
if (cm)
delete cm;
if (sm)
delete sm;
if (fm)
delete fm;
if (pm)
delete pm;
if (nm)
delete nm;
if (dm)
delete dm;
// SW: START: SendPriorityManager
if (spm)
delete spm;
// SW: END: SendPriorityManager
if (am)
delete am;
// SW: start interest manager
if (im)
delete im;
// SW: end interest manager
#if defined(ENABLE_DEBUG_MANAGER)
if (db)
delete db;
#endif
if (rm)
delete rm;
#ifdef OS_WINDOWS_MOBILE
tray_notification_remove();
#endif
delete kernel;
kernel = NULL;
xmlCleanupParser(); // MOS
return retval;
}
int run_haggle()
{
#ifdef ENABLE_DEBUG_MANAGER
DebugManager *db = NULL;
#endif
ApplicationManager *am = NULL;
DataManager *dm = NULL;
NodeManager *nm = NULL;
ProtocolManager *pm = NULL;
ForwardingManager *fm = NULL;
SecurityManager *sm = NULL;
ConnectivityManager *cm = NULL;
#ifdef BENCHMARK
BenchmarkManager *bm = NULL;
//recreateDataStore = true;
#endif
ResourceManager *rm = NULL;
ProtocolSocket *p = NULL;
#ifdef OS_WINDOWS_MOBILE
// For testing we force the deletion of the data store
//recreateDataStore = true;
#endif
int retval = EXIT_FAILURE;
if (!create_path(HAGGLE_DEFAULT_STORAGE_PATH)) {
HAGGLE_ERR("Could not create Haggle storage path : %s\n", HAGGLE_DEFAULT_STORAGE_PATH);
return -1;
}
retval = write_pid_file(getpid());
if (retval != HAGGLE_PROCESS_NO_ERROR) {
switch (retval) {
case HAGGLE_PROCESS_BAD_PID:
HAGGLE_ERR("Cannot read PID file %s.\n", PID_FILE.c_str());
break;
case HAGGLE_PROCESS_CANNOT_WRITE_PID:
HAGGLE_ERR("Cannot write PID file %s\n", PID_FILE.c_str());
break;
case HAGGLE_PROCESS_ALREADY_RUNNING:
HAGGLE_ERR("PID file %s indicates that Haggle is already running.\n", PID_FILE.c_str());
break;
default:
HAGGLE_ERR("Unknown PID file error\n");
}
shouldCleanupPidFile = false;
return -1;
}
#if defined(OS_UNIX) && !defined(OS_ANDROID)
setrawtty();
#endif
/* Seed the random number generator */
prng_init();
kernel = new HaggleKernel(new SQLDataStore(recreateDataStore));
if (!kernel || !kernel->init()) {
fprintf(stderr, "Kernel initialization error!\n");
return -1;
}
// Build a Haggle configuration
am = new ApplicationManager(kernel);
if (!am || !am->init()) {
HAGGLE_ERR("Could not initialize application manager\n");
goto finish;
}
dm = new DataManager(kernel, setCreateTimeOnBloomfilterUpdate);
if (!dm || !dm->init()) {
HAGGLE_ERR("Could not initialize data manager\n");
goto finish;
}
nm = new NodeManager(kernel);
if (!nm || !nm->init()) {
HAGGLE_ERR("Could not initialize node manager\n");
goto finish;
}
pm = new ProtocolManager(kernel);
if (!pm || !pm->init()) {
HAGGLE_ERR("Could not initialize protocol manager\n");
goto finish;
}
fm = new ForwardingManager(kernel);
if (!fm || !fm->init()) {
HAGGLE_ERR("Could not initialize forwarding manager\n");
goto finish;
}
sm = new SecurityManager(kernel, securityLevel);
if (!sm || !sm->init()) {
HAGGLE_ERR("Could not initialize security manager\n");
goto finish;
}
#ifdef USE_UNIX_APPLICATION_SOCKET
p = new ProtocolLOCAL(kernel->getStoragePath() + "/" + HAGGLE_LOCAL_SOCKET, pm);
if (!p || !p->init()) {
HAGGLE_ERR("Could not initialize LOCAL protocol\n");
goto finish;
}
p->setFlag(PROT_FLAG_APPLICATION);
p->registerWithManager();
#endif
p = new ProtocolUDP("127.0.0.1", HAGGLE_SERVICE_DEFAULT_PORT, pm);
/* Add ConnectivityManager last since it will start to
* discover interfaces and generate events. At that
* point the other managers should already be
* running. */
if (!p || !p->init()) {
HAGGLE_ERR("Could not initialize UDP Application protocol\n");
goto finish;
}
p->setFlag(PROT_FLAG_APPLICATION);
p->registerWithManager();
rm = new ResourceManager(kernel);
if (!rm || !rm->init()) {
HAGGLE_ERR("Could not initialize resource manager\n");
goto finish;
}
#ifdef BENCHMARK
if (!isBenchmarking) {
#endif
cm = new ConnectivityManager(kernel);
if (!cm || !cm->init()) {
HAGGLE_ERR("Could not initialize connectivity manager\n");
goto finish;
}
#ifdef BENCHMARK
} else {
bm = new BenchmarkManager(kernel, Benchmark_DataObjects_Attr, Benchmark_Nodes_Attr, Benchmark_Attr_Num, Benchmark_DataObjects_Num, Benchmark_Test_Num);
if (!bm || !bm->init()) {
HAGGLE_ERR("Could not initialize benchmark manager\n");
goto finish;
}
}
#endif
#if defined(ENABLE_DEBUG_MANAGER)
// It seems as if there can be only one accept() per
// thread... we need to make the DebugManager register
// protocol or something with the ProtocolTCPServer
// somehow
db = new DebugManager(kernel, runAsInteractive);
if (!db || !db->init()) {
HAGGLE_ERR("Could not initialize debug manager\n");
/* Treat as non critical error. */
}
#endif
HAGGLE_DBG("Starting Haggle...\n");
#ifdef OS_WINDOWS_MOBILE
if (platform_type(current_platform()) == platform_windows_mobile_professional)
tray_notification_add(g_hInstance, kernel);
#endif
kernel->run();
retval = EXIT_SUCCESS;
HAGGLE_DBG("Haggle finished...\n");
finish:
#ifdef BENCHMARK
if (bm)
delete bm;
#endif
if (cm)
delete cm;
if (sm)
delete sm;
if (fm)
delete fm;
if (pm)
delete pm;
if (nm)
delete nm;
if (dm)
delete dm;
if (am)
delete am;
#if defined(ENABLE_DEBUG_MANAGER)
if (db)
delete db;
#endif
if (rm)
delete rm;
#ifdef OS_WINDOWS_MOBILE
tray_notification_remove();
#endif
delete kernel;
kernel = NULL;
return retval;
}