void TCPCONNECTIONTF::testClose()
{
TCPServerAdapter adapter;
Transport *tranServer = new Transport;
char spec[] = "tcp:localhost:13345";
tranServer->start();
IOComponent *listener = tranServer->listen(spec, _streamer, &adapter);
CPPUNIT_ASSERT(listener);
//start client
Transport *tranClient = new Transport;
tranClient->start();
Connection *conn = tranClient->connect(spec, _streamer, false);
CPPUNIT_ASSERT(conn);
CPPUNIT_ASSERT(_conn->postPacket(new ConnPacket(31), _handler, NULL));
// the close() has not implement
ANET_LOG(SPAM,"Before Calling _conn->close();");
_conn->close();
ANET_LOG(SPAM,"After Calling _conn->close();");
CPPUNIT_ASSERT(_conn->isClosed());
ANET_LOG(SPAM,"After Assert(_conn->isClosed();");
tranClient->stop();
ANET_LOG(SPAM,"After Calling tranClient->stop();");
tranClient->wait();
ANET_LOG(SPAM,"After Calling tranClient->wait();");
tranServer->stop();
ANET_LOG(SPAM,"After Calling tran_server->stop();");
tranServer->wait();
ANET_LOG(SPAM,"After Calling tranClient->wait();");
delete tranClient;
delete tranServer;
listener->subRef();
conn->subRef();
}
int main()
{
signal(SIGPIPE, sigHandler);
signal(SIGHUP, sigHandler);
Transport gClientTrans;
gClientTrans.start();
EchoServer server;
server.start();
for (int i = 0; i < 1; i++)
{
EchoClient* client = new EchoClient;
client->mClientTrans = &gClientTrans;
cout << "Round " << i << endl;
client->Run();
usleep(100000);
waitpid(-1, NULL, WNOHANG);
}
gClientTrans.stop();
gClientTrans.wait();
server.stop();
}
void EchoServer::stop()
{
_transport.stop();
}
void doProcess(unsigned int port, unsigned int num, CMClient& client)
{
Transport transport;
transport.start(); //using multithreads mode of anet
Thread *threads = new Thread[num];
RequestProcessor *runnables = new RequestProcessor [num];
assert(threads);
assert(runnables);
for (long i=0; i<num; i++) {
threads[i].start(runnables + i, (void*)&client);
}
HTTPPacketFactory factory;
HTTPStreamer streamer(&factory);
HTTPServerAdapter serverAdapter;
stringstream ss;
char hostname[1024];
if (gethostname(hostname, 1024) != 0) {
transport.stop();
transport.wait();
delete [] threads;
delete [] runnables;
exit(-1);
}
// ss << "tcp:" << hostname << ":" << port;
ss << "tcp:" << ":" << port;
string str = ss.str();
const char *spec = str.c_str();
IOComponent *ioc = transport.listen(spec, &streamer, &serverAdapter);
if (ioc == NULL) {
printf("create listen port error\n");
transport.stop();
transport.wait();
delete [] threads;
delete [] runnables;
return;
}
printf("webserver start ok\n");
while (!globalStopFlag) {
usleep(100000);
}
transport.stop();
transport.wait();
globalQueue._condition.lock();
while (globalQueue._queue.size()) {
HTTPRequestEntry entry = globalQueue._queue.front();
entry._packet->free();
entry._connection->subRef();
globalQueue._queue.pop();
}
globalQueue._condition.broadcast();
globalQueue._condition.unlock();
for (long i=0; i<num; i++) {
threads[i].join();
}
delete [] threads;
delete [] runnables;
}
bool HostFilterComponent::perform (const InvocationInfo& info)
{
Config* config = Config::getInstance();
GraphComponent* graph = main->getGraph ();
Transport* transport = getFilter()->getTransport();
switch (info.commandID)
{
//----------------------------------------------------------------------------------------------
case CommandIDs::pluginOpen:
{
graph->loadAndAppendPlugin ();
break;
}
case CommandIDs::pluginClose:
{
graph->closeSelectedPlugins ();
break;
}
case CommandIDs::pluginClear:
{
graph->closeAllPlugins ();
break;
}
case CommandIDs::showPluginListEditor:
{
if (PluginListWindow::currentPluginListWindow == 0)
PluginListWindow::currentPluginListWindow = new PluginListWindow (knownPluginList);
PluginListWindow::currentPluginListWindow->toFront (true);
break;
}
//----------------------------------------------------------------------------------------------
#ifndef JOST_VST_PLUGIN
case CommandIDs::audioOptions:
{
StandaloneFilterWindow* window = findParentComponentOfClass ((StandaloneFilterWindow*) 0);
if (window)
window->showAudioSettingsDialog ();
break;
}
#endif
case CommandIDs::audioPlay:
{
transport->play ();
break;
}
case CommandIDs::audioPlayPause:
{
transport->togglePlay ();
break;
}
case CommandIDs::audioStop:
{
transport->stop ();
break;
}
case CommandIDs::audioRecord:
{
transport->record ();
break;
}
case CommandIDs::audioRewind:
{
transport->rewind ();
break;
}
case CommandIDs::audioLoop:
{
transport->setLooping (! transport->isLooping());
break;
}
//----------------------------------------------------------------------------------------------
case CommandIDs::sessionNew:
{
bool retValue =
AlertWindow::showYesNoCancelBox (AlertWindow::WarningIcon,
T("Unsaved Changes"),
T("Are you sure you want to close the current session? You may lose any unsaved changes."));
if (retValue)
{
closePluginEditorWindows ();
getFilter()->getHost ()->closeAllPlugins (true);
clearComponents ();
Config::getInstance()->lastSessionFile = File::nonexistent;
rebuildComponents ();
}
break;
}
case CommandIDs::sessionLoad:
{
FileChooser myChooser (T("Load a session file..."),
Config::getInstance ()->lastSessionDirectory,
JOST_SESSION_WILDCARD, JOST_USE_NATIVE_FILE_CHOOSER);
if (myChooser.browseForFileToOpen())
{
bool retValue =
AlertWindow::showYesNoCancelBox (AlertWindow::WarningIcon,
T("Unsaved Changes"),
T("Are you sure you want to close the current session? You may lose any unsaved changes."));
if (retValue)
{
MemoryBlock fileData;
File fileToLoad = myChooser.getResult();
if (fileToLoad.existsAsFile()
&& fileToLoad.loadFileAsData (fileData))
{
getFilter ()->setStateInformation (fileData.getData (), fileData.getSize());
Config::getInstance()->addRecentSession (fileToLoad);
Config::getInstance()->lastSessionFile = fileToLoad;
}
}
}
break;
}
case CommandIDs::sessionSave:
{
handleSaveCommand();
break;
}
case CommandIDs::sessionSaveNoPrompt:
{
handleSaveCommand(true);
break;
}
case CommandIDs::audioStemsStartStop:
{
getHost()->toggleStemRendering();
break;
}
case CommandIDs::audioStemsSetup:
{
FileChooser myChooser (T("Save Rendered Stem Files To..."),
Config::getInstance ()->lastStemsDirectory);
if (myChooser.browseForDirectory ())
{
Config::getInstance ()->lastStemsDirectory = myChooser.getResult();
}
break;
}
//----------------------------------------------------------------------------------------------
case CommandIDs::appToolbar:
{
toolbar->showCustomisationDialog (*factory,
Toolbar::allCustomisationOptionsEnabled);
// (Toolbar::allowIconsOnlyChoice | Toolbar::showResetToDefaultsButton));
break;
}
case CommandIDs::appBrowser:
{
setBrowserVisible (! config->showBrowser, config->browserLeft);
break;
}
case CommandIDs::appFullScreen:
{
DocumentWindow* window = findParentComponentOfClass <DocumentWindow> ();
if (window) {
window->setFullScreen (! window->isFullScreen ());
window->setMenuBar (window->isFullScreen () ? 0 : this);
}
break;
}
case CommandIDs::appExit:
{
deleteAndZero(PluginListWindow::currentPluginListWindow);
JUCEApplication::getInstance()->systemRequestedQuit();
break;
}
case CommandIDs::appAbout:
{
// Image* splashImage = ImageCache::getFromMemory (Resource::jost_about,
// Resource::jost_about_size);
// todo: move appResourcesFolder() to somewhere everyone can use it
#if JUCE_MAC
File appResourcesFolder(File::getSpecialLocation(File::currentApplicationFile).getChildFile("./Contents/Resources"));
#else
File appResourcesFolder(File::getSpecialLocation(File::currentApplicationFile).getParentDirectory());
#endif
File splashImageFile(appResourcesFolder.getChildFile("JiveAbout.png"));
Image* splashImage = ImageFileFormat::loadFrom(splashImageFile);
SplashScreen* splash = new SplashScreen();
splash->show (T(JucePlugin_Name), splashImage, 3500, false);
break;
}
//----------------------------------------------------------------------------------------------
default:
return false;
}
return true;
}
int main(int argc, char *argv[]) {
if(2 > argc) {
printf("Less address!\n");
return 1;
}
Logger::logSetup();
Logger::setLogLevel(0);
char *address = argv[1];
char host[100] = {0};
char path[1024*1024] = {0};
char spec[200] = {0};
int port = -1;
sscanf(address, "http://%[-a-zA-Z0-9.]:%d%s", host, &port, path);
if(0 == host[0] || -1 == port) {
sscanf(address, "%[-a-zA-Z0-9.]:%d%s", host, &port, path);
}
if(0 == host[0] || -1 == port) {
port = 80;
sscanf(address, "http://%[-a-zA-Z0-9.]%s", host, path);
}
if(0 == host[0] || -1 == port) {
sscanf(address, "%[-a-zA-Z0-9.]%s", host, path);
}
if(0 == host[0] || -1 == port) {
printf("Wrong address!\n");
return 1;
}
if(0 == path[0]) {
path[0] = '/';
path[1] = 0;
}
sprintf(spec, "tcp:%s:%d", host, port);
Transport transport;
transport.start();
Connection *connection = NULL;
HTTPPacketFactory factory;
HTTPStreamer streamer(&factory);
connection = transport.connect(spec, &streamer);
if (NULL == connection) {
printf("Failed to connect server %s\n", spec);
exit(1);
}
HTTPPacket *requst = new HTTPPacket;
requst->setMethod(HTTPPacket::HM_GET);
requst->setURI(path);
requst->addHeader("Accept", "*/*");
requst->addHeader("Connection", "Keep-Alive");
requst->addHeader("Host", (const char*)(spec+4));
Packet *ret = connection->sendPacket(requst);
HTTPPacket *reply = NULL;
if (NULL != ret && ret->isRegularPacket()
&& (reply = dynamic_cast<HTTPPacket*>(ret)))
{
printf("------------reply from '%s' ----------\r\n", address);
printf("%s %d %s\r\n", reply->getVersion() ? "HTTP/1.1" : "HTTP/1.0",
reply->getStatusCode(), reply->getReasonPhrase());
for (HTTPPacket::ConstHeaderIterator it = reply->headerBegin();
it != reply->headerEnd(); it ++)
{
printf("%s: %s\r\n", it->first, it->second);
}
printf("\r\n");
if (reply->getBody()) {
fwrite(reply->getBody(), 1, reply->getBodyLen(), stdout);
}
printf("\n-----------end of reply-------------------\n");
} else {
printf("Fail to get reply from '%s' ----------\r\n", address);
ControlPacket *cmd = dynamic_cast<ControlPacket*>(ret);
if (cmd) {
printf("%s", cmd->what());
}
}
connection->subRef();
transport.stop();
transport.wait();
return 0;
}
