acPool(int32_t max_idle, bool bThread = false)
: m_bThread(bThread)
, m_max_idle(max_idle)
, m_idleWorkers(1)
{
new_worker();
}
void worker_proc()
{
Runtime rt(NULL);
AsyncEvent *p;
m_idleWorkers.dec();
while (true)
{
if (m_idleWorkers.inc() > MAX_IDLE_WORKERS)
{
if (m_idleWorkers.dec() > 0)
break;
m_idleWorkers.inc();
}
p = m_pool.get();
if (m_idleWorkers.dec() == 0)
if (m_idleWorkers.CompareAndSwap(0, 1) == 0)
new_worker();
p->invoke();
}
}
int main(void)
{
struct sockaddr_in serverend;
socklen_t len;
int sd, ret, shmid, epfd;
struct epoll_event revents;
len = sizeof(serverend);
pid_t pid;
serverend.sin_family = AF_INET;
serverend.sin_port = htons(SERVERPORT);
inet_pton(AF_INET, SERVERADDR, &serverend.sin_addr);
sd = socket(AF_INET, SOCK_STREAM, 0);
if (-1 == sd)
{
perror("socket");
exit(1);
}
ret = bind(sd, (struct sockaddr *)&serverend, len);
if (-1 == ret)
{
perror("bind");
exit(1);
}
ret = listen(sd, 30);
ret = fcntl(sd, F_GETFL);
ret = fcntl(sd, F_SETFL, ret | O_NONBLOCK);
if (-1 == ret)
printf("listen\n");
desory_zmobe();
Prolib_t *lib = create_dynamic_process_libs(sd, 3);
epfd = InitEpoll(sd);
shmid = init_shmid(sd);
while (1)
{
ret = epoll_wait(epfd, &revents, 1, -1);
if (ret >= 0)
{
if (revents.events & EPOLLIN)
{
printf("new connect is coming!, ret: %d\n", ret);
ret = assign_job(lib, 3, task);
if (-1 == ret)
new_worker(lib, 3, shmid);
}
}
}
}
void LoadBalancer::removeWorker(pid_t pid) {
for (size_t i=0; i<worker_proc.size(); ++i)
if (worker_proc[i] && worker_proc[i]->pid() == pid) {
if (max_retries) {
--max_retries;
} else {
setResult("Too many failures");
}
new_worker(i);
break;
}
}
double LoadBalancer::start() {
if (!tot_no_workers) {
setError("Internal error, no workers");
return 0.0;
}
worker_proc.resize(tot_no_workers);
if (parseListen(my_config, "LoadBalancerSocket")) {
for (size_t i=0; i<tot_no_workers; ++i)
new_worker(i);
} else {
setResult("Failed, cannot start server");
}
return 0.0;
}
Result Scheduler::init() {
Result rc = S_OK;
// for now, just create one local worker process
int pid = fork();
if (pid < 0) {
reportError(__FUNCTION__, __LINE__, "Error forking process");
rc = S_FAIL;
} else if (pid == 0) {
std::string worker_file("inc/worker.o");
char *argv[] = {};
execv((BASEDIR + worker_file).c_str(), argv);
reportError(__FUNCTION__, __LINE__, "execv failed");
exit(1);
} else {
Worker new_worker(pid, 0);
workers.push(new_worker);
}
return rc;
}
acPool(bool bThread = false) : m_bThread(bThread), m_idleWorkers(1)
{
new_worker();
}
MainFrame::MainFrame(wxWindow* parent,wxWindowID id)
: my::employer(L"MainFrame_employer", false)
, Cartographer(0)
, Anchor_(NoAnchor)
, WiFi_data_(NULL)
, WiFi_relative_mode_(true)
, WiFi_min_power_(-100)
, WiFi_max_power_(10)
, WiFi_min_power_abs_(-100)
, WiFi_max_power_abs_(10)
, MY_MUTEX_DEF(WiFi_mutex_,true)
, big_font_(0)
, small_font_(0)
, gps_tracker_id_(0)
, green_mark_id_(0)
, red_mark_id_(0)
, yellow_mark_id_(0)
, pg_conn_(NULL)
, MY_MUTEX_DEF(pg_mutex_,true)
, Gps_test_(false)
, MY_MUTEX_DEF(Gps_mutex_,true)
{
#undef _
#define _(s) (L##s)
//(*Initialize(MainFrame)
wxMenu* MenuHelp;
wxMenuItem* MenuAbout;
wxMenuBar* MainMenu;
wxMenu* MenuFile;
wxMenuItem* MenuQuit;
Create(parent, wxID_ANY, _("Scan Analitics"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE, _T("wxID_ANY"));
SetClientSize(wxSize(626,293));
SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
FlexGridSizer1 = new wxFlexGridSizer(1, 1, 0, 0);
FlexGridSizer1->AddGrowableCol(0);
FlexGridSizer1->AddGrowableRow(0);
Panel1 = new wxPanel(this, ID_PANEL1, wxDefaultPosition, wxSize(616,331), wxTAB_TRAVERSAL, _T("ID_PANEL1"));
FlexGridSizer1->Add(Panel1, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
SetSizer(FlexGridSizer1);
MainMenu = new wxMenuBar();
MenuFile = new wxMenu();
MenuSettings = new wxMenuItem(MenuFile, ID_SETTINGS, _("Настройки..."), wxEmptyString, wxITEM_NORMAL);
MenuFile->Append(MenuSettings);
MenuFile->AppendSeparator();
MenuQuit = new wxMenuItem(MenuFile, ID_QUIT, _("Выход\tAlt-F4"), wxEmptyString, wxITEM_NORMAL);
MenuFile->Append(MenuQuit);
MainMenu->Append(MenuFile, _("Файл"));
MenuView = new wxMenu();
MenuMaps = new wxMenu();
MenuMapsNull = new wxMenuItem(MenuMaps, 0, _("Нет карт"), wxEmptyString, wxITEM_RADIO);
MenuMaps->Append(MenuMapsNull);
MenuView->Append(ID_MENUMAPS, _("Карты"), MenuMaps, wxEmptyString);
MenuView->AppendSeparator();
MenuZoomIn = new wxMenuItem(MenuView, ID_ZOOMIN, _("Увеличить масштаб"), wxEmptyString, wxITEM_NORMAL);
MenuView->Append(MenuZoomIn);
MenuZoomOut = new wxMenuItem(MenuView, ID_ZOOMOUT, _("Уменьшить масштаб"), wxEmptyString, wxITEM_NORMAL);
MenuView->Append(MenuZoomOut);
MenuView->AppendSeparator();
MenuGpsTracker = new wxMenuItem(MenuView, ID_GPSTRACKER, _("Загружать данные с Gps"), wxEmptyString, wxITEM_CHECK);
MenuView->Append(MenuGpsTracker);
MenuGpsAnchor = new wxMenuItem(MenuView, ID_GPSANCHOR, _("Следить за Gps"), wxEmptyString, wxITEM_CHECK);
MenuView->Append(MenuGpsAnchor);
MenuView->AppendSeparator();
MenuWifiScan = new wxMenuItem(MenuView, ID_WIFISCAN, _("Загружать данные с WiFi-сканера"), wxEmptyString, wxITEM_CHECK);
MenuView->Append(MenuWifiScan);
MenuWiFiAnchor = new wxMenuItem(MenuView, ID_WIFIANCHOR, _("Следить за данными WiFi-сканера"), wxEmptyString, wxITEM_CHECK);
MenuView->Append(MenuWiFiAnchor);
MainMenu->Append(MenuView, _("Вид"));
MenuHelp = new wxMenu();
MenuAbout = new wxMenuItem(MenuHelp, ID_ABOUT, _("О программе...\tF1"), wxEmptyString, wxITEM_NORMAL);
MenuHelp->Append(MenuAbout);
MainMenu->Append(MenuHelp, _("Помощь"));
SetMenuBar(MainMenu);
StatusBar1 = new wxStatusBar(this, ID_STATUSBAR1, 0, _T("ID_STATUSBAR1"));
int __wxStatusBarWidths_1[1] = { -1 };
int __wxStatusBarStyles_1[1] = { wxSB_NORMAL };
StatusBar1->SetFieldsCount(1,__wxStatusBarWidths_1);
StatusBar1->SetStatusStyles(1,__wxStatusBarStyles_1);
SetStatusBar(StatusBar1);
FlexGridSizer1->SetSizeHints(this);
Connect(ID_SETTINGS,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&MainFrame::OnSettings);
Connect(ID_QUIT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&MainFrame::OnQuit);
Connect(ID_ZOOMIN,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&MainFrame::OnZoomIn);
Connect(ID_ZOOMOUT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&MainFrame::OnZoomOut);
Connect(ID_GPSTRACKER,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&MainFrame::OnGpsTracker);
Connect(ID_GPSANCHOR,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&MainFrame::OnGpsAnchor);
Connect(ID_WIFISCAN,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&MainFrame::OnWiFiScan);
Connect(ID_WIFIANCHOR,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&MainFrame::OnWiFiAnchor);
Connect(ID_ABOUT,wxEVT_COMMAND_MENU_SELECTED,(wxObjectEventFunction)&MainFrame::OnAbout);
//*)
setlocale(LC_NUMERIC, "C");
{
wxIcon FrameIcon;
FrameIcon.CopyFromBitmap(LoadBitmapFromC(images::cartographer));
SetIcon(FrameIcon);
}
MainToolBar = new wxToolBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTB_HORIZONTAL|wxNO_BORDER);
MainToolBar->AddTool(ID_ZOOMIN, L"ZoomIn", LoadBitmapFromC(images::zoom_in), L"Увеличить");
MainToolBar->AddTool(ID_ZOOMOUT, L"ZoomOut", LoadBitmapFromC(images::zoom_out), L"Уменьшить");
MainToolBar->AddSeparator();
MainToolBar->AddTool(ID_GPSTRACKER, L"GpsTracker", LoadBitmapFromC(images::gps_tracker), L"Gps", wxITEM_CHECK);
MainToolBar->AddTool(ID_GPSANCHOR, L"GpsAnchor", LoadBitmapFromC(images::anchor), L"Следить за Gps", wxITEM_CHECK);
MainToolBar->AddSeparator();
MainToolBar->AddTool(ID_WIFISCAN, L"WiFiScan", LoadBitmapFromC(images::wifi), L"WiFi", wxITEM_CHECK);
MainToolBar->AddTool(ID_WIFIANCHOR, L"WiFiAnchor", LoadBitmapFromC(images::anchor), L"Следить за WiFi", wxITEM_CHECK);
MainToolBar->Realize();
SetToolBar(MainToolBar);
ReloadSettings();
{
int w, h;
bool maximized;
MyConfig->Read(L"/MainFrame/Width", &w, 400);
MyConfig->Read(L"/MainFrame/Height", &h, 400);
MyConfig->Read(L"/MainFrame/Maximized", &maximized, true);
SetClientSize(w, h);
Maximize(maximized);
}
Show(true);
/* Создание Картографа на месте Panel1 */
{
delete Panel1;
std::wstring error;
bool only_cache
= MyConfig->ReadBool(L"/Cartographer/OnlyCache", false);
if (!only_cache)
{
wxString str = MyConfig->Read(L"/Cartographer/ServerAddr", L"");
try
{
Cartographer = new cartographer::Painter(this,
(const wchar_t*)str.c_str());
}
catch (my::exception &e)
{
/* Не удалось создать Картограф - возможно
не получилось соединиться с сервером */
error = e.message();
only_cache = true;
}
}
if (only_cache)
{
try
{
Cartographer = new cartographer::Painter(this, L"cache");
}
catch (my::exception &e)
{
if (error.empty())
throw e;
else
throw my::exception(error);
}
}
FlexGridSizer1->Add(Cartographer, 1, wxALL|wxEXPAND|wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 5);
SetSizer(FlexGridSizer1);
if (!error.empty())
{
wxMessageBox(L"Не удалось запустить Картограф"
L" с заданными настройками. Картограф запущен"
L" в режиме работы с кэшем.\n\nТекст ошибки:\n\n"
+ error, L"Ошибка", wxOK | wxICON_ERROR,
this);
}
} /* Создание Картографа */
Cartographer->Bind(wxEVT_MOTION, &MainFrame::OnMapMouseMove, this, wxID_ANY);
/* Создаём шрифты */
big_font_ = Cartographer->CreateFont(
wxFont(12, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD) );
small_font_ = Cartographer->CreateFont(
wxFont(8, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD) );
/* Загружаем список карт */
{
MenuMaps->Delete(MenuMapsNull);
cartographer::map_info active_map = Cartographer->GetActiveMapInfo();
long maps_count = Cartographer->GetMapsCount();
for(long i = 0; i < maps_count; ++i)
{
cartographer::map_info map = Cartographer->GetMapInfo(i);
wxMenuItem *item = new wxMenuItem(MenuMaps, i,
map.name + L"\t" + my::num::to_wstring(i + 1),
wxEmptyString, wxITEM_RADIO);
MenuMaps->Append(item);
if (active_map.sid == map.sid)
item->Check();
MenuMaps->Bind(wxEVT_COMMAND_MENU_SELECTED, &MainFrame::OnMapChange, this, i);
}
}
/* Изображения */
gps_tracker_id_ = Cartographer->LoadImageFromC(images::gps_tracker);
Cartographer->SetImageCentralPoint(gps_tracker_id_, 15.5, 19.0);
green_mark_id_ = Cartographer->LoadImageFromC(images::green_mark);
red_mark_id_ = Cartographer->LoadImageFromC(images::red_mark);
yellow_mark_id_ = Cartographer->LoadImageFromC(images::yellow_mark);
/* Запускаем собственную прорисовку */
Cartographer->SetPainter(
boost::bind(&MainFrame::OnMapPaint, this, _1, _2));
Cartographer->SetStatusHandler(
boost::bind(&MainFrame::StatusHandler, this, _1));
Cartographer->MoveTo(13,
cartographer::DMSToDD( 48,28,48.77, 135,4,19.04 ));
//UpdateWiFiData( macaddr(0, 0x10, 0xE7, 0xA4, 0x46, 0x9D) );
WiFiScan_worker_ = new_worker( L"WiFiScan_worker");
GpsTracker_worker_ = new_worker( L"GpsTracker_worker");
boost::thread( boost::bind(
&MainFrame::CheckerProc, this, new_worker(L"Checker_worker")) );
}
