void XmlConfManager::changeUser(QString server, User user) {
QDomElement serverElement = findServer(server);
QDomElement userElement = serverElement.firstChildElement("user");
serverElement.removeChild(userElement);
/* Recréation de l'utilisateur */
userElement = confDesc.createElement("user");
QDomElement nickname = confDesc.createElement("nickname");
QDomElement ghost = confDesc.createElement("ghost");
QDomElement username = confDesc.createElement("username");
QDomElement realname = confDesc.createElement("realname");
QDomText nickText = confDesc.createTextNode(user.nickname);
QDomText ghostText = confDesc.createTextNode(user.ghost);
QDomText usernameText = confDesc.createTextNode(user.username);
QDomText realnameText = confDesc.createTextNode(user.realname);
nickname.appendChild(nickText);
ghost.appendChild(ghostText);
username.appendChild(usernameText);
realname.appendChild(realnameText);
userElement.appendChild(nickname);
userElement.appendChild(ghost);
userElement.appendChild(username);
userElement.appendChild(realname);
serverElement.appendChild(userElement);
}
CSmodule_AbstractDisplay *CSmodule_AbstractDisplay::findServer(CSmodContainer *container, const char *servername)
{
for (int i=0;i<container->nr;i++)
{
CSmodule_AbstractDisplay *m =
dynamic_cast<CSmodule_AbstractDisplay*>(container->module[i]);
if (m)
{
int ip = m->getPropertyIndex("serverstr");
if (ip>=0)
{
if (!strcmp(servername, m->property[ip]->svalue))
// found
return m;
}
}
// check sub-containers
CSmodule_Container *mc =
dynamic_cast<CSmodule_Container*>(container->module[i]);
if (mc)
{
CSmodule_AbstractDisplay *mo =
findServer(mc->container, servername);
if (mo) return mo;
}
}
return 0;
}
void QSfwTestUtil::removeDatabases_symbian()
{
#if defined(__WINS__) && !defined(SYMBIAN_EMULATOR_SUPPORTS_PERPROCESS_WSD)
QDir dir("C:/Data/temp/QtServiceFW");
#else
TFindServer findServer(_L("!qsfwdatabasemanagerserver"));
TFullName name;
if (findServer.Next(name) == KErrNone)
{
RProcess dbServer;
if (dbServer.Open(_L("qsfwdatabasemanagerserver")) == KErrNone)
{
dbServer.Kill(KErrNone);
dbServer.Close();
}
}
QDir dir("c:/private/2002AC7F");
#endif
QString qtVersion(qVersion());
qtVersion = qtVersion.left(qtVersion.size() - 2); //strip off patch version
QString dbIdentifier = "_system";
QString dbName = QString("QtServiceFramework_") + qtVersion + dbIdentifier + QLatin1String(".db");
QFile::remove(QDir::toNativeSeparators(dir.path() + QDir::separator() + dbName));
}
/*
* TrackServerMsg - update the coversations tracking window
*/
void TrackServerMsg( MONCBSTRUCT *info )
{
char *inst;
DDETrackInfo *listinfo;
ServerInfo **entry;
ServerInfo *cur;
inst = HSZToString( info->hsz2 );
listinfo = (DDETrackInfo *)GetWindowLong(
Tracking[DDEMENU_TRK_SERVER - DDE_TRK_FIRST].hwnd, 0 );
entry = findServer( inst, listinfo );
if( info->wType == XTYP_REGISTER ) {
if( entry == NULL ) {
entry = getNextPos( listinfo );
cur = MemAlloc( sizeof( ServerInfo ) );
*entry = cur;
cur->instname = inst;
cur->server = HSZToString( info->hsz1 );
} else {
MemFree( inst );
}
} else if( info->wType == XTYP_UNREGISTER ) {
if( entry != NULL ) {
cur = *entry;
MemFree( cur->instname );
MemFree( cur->server );
*entry = NULL;
} else {
MemFree( inst );
}
}
displayServers( listinfo );
} /* TrackServerMsg */
void SocketLibrary::initialize()
{
//check if server ip defined, if not, find the server by broadcasting UDP packets
if(serverIp == "")
{
UdpSocket findServer(*socket_handler);
findServer.SetBroadcast(true);
findServer.SendTo("255.255.255.255",DFCDConfig::SERVER_PORT,"4445"); //broadcast to everyone!
//SocketHandler h2;
UDPChatSocket serverReply(*socket_handler);
port_t clientPort = 4445;
if (serverReply.Bind(clientPort,1) == -1)
{
printf("Exiting...\n");
exit(-1);
}
socket_handler->Add(&serverReply);
socket_handler->Select(1,0);
while (socket_handler->GetCount())
{
socket_handler->Select(1,0);
if(serverReply.serverIp!= "")
{
serverIp = serverReply.serverIp;
break;
}
}
}
client_socket->Open(serverIp,DFCDConfig::SERVER_PORT);
socket_handler->Add(client_socket);
socket_handler->Select(.01,0);
}
QString XmlConfManager::getPortByName(QString serverName) {
return
findServer(serverName).
firstChildElement("network").
firstChildElement("port").
text();
}
void XmlConfManager::changeCommand(QString server, QString code) {
QDomElement serverElement = findServer(server);
QDomElement changeCommand = serverElement.firstChildElement("command");
serverElement.removeChild(changeCommand);
changeCommand = confDesc.createElement("command");
QDomText command = confDesc.createTextNode(code);
changeCommand.appendChild(command);
serverElement.appendChild(changeCommand);
}
void MGHPCCPod::setFanSpeed(const std::string &rackName, const std::string &serverName,
int fanSpeed)
{
Server *server = findServer(rackName, serverName);
if(!server){
LOG_ERROR << "Server is null.";
return;
}
server->setFanSpeed(fanSpeed);
VLOG_2 << "Setting fan speed " << fanSpeed << " of server " << serverName
<< " of rack " << rackName ;
}
void XmlConfManager::addNetwork(QString server, Network network) {
QDomElement networkSubElement = confDesc.createElement("network");
QDomElement host = confDesc.createElement("host");
QDomElement port = confDesc.createElement("port");
QDomText hostText = confDesc.createTextNode(network.host);
QDomText portText = confDesc.createTextNode(network.port);
host.appendChild(hostText);
port.appendChild(portText);
networkSubElement.appendChild(host);
networkSubElement.appendChild(port);
findServer(server).appendChild(networkSubElement);
}
void dispatch()
/* Look at input variables and figure out which page to show. */
{
char *db, *organism;
int maxSize = 4000;
int minPerfect = 15;
int minGood = 15;
char *fPrimer = cartUsualString(cart, "wp_f", "");
char *rPrimer = cartUsualString(cart, "wp_r", "");
boolean flipReverse = cartUsualBoolean(cart, "wp_flipReverse", FALSE);
struct pcrServer *serverList = getServerList();
getDbAndGenome(cart, &db, &organism, oldVars);
/* Get variables. */
maxSize = cartUsualInt(cart, "wp_size", maxSize);
minPerfect = cartUsualInt(cart, "wp_perfect", minPerfect);
minGood = cartUsualInt(cart, "wp_good", minGood);
if (minPerfect < 15)
minPerfect = 15;
if (minGood < minPerfect)
minGood = minPerfect;
/* Decide based on transient variables what page to put up.
* By default put up get primer page. */
if (isNotEmpty(fPrimer) && isNotEmpty(rPrimer) &&
!cartVarExists(cart, "wp_showPage"))
{
struct pcrServer *server = NULL;
struct targetPcrServer *targetServer = NULL;
char *target = cartUsualString(cart, "wp_target", "genome");
if (isEmpty(target) || sameString(target, "genome"))
server = findServer(db, serverList);
else
{
targetServer = getTargetServerList(db, target);
if (targetServer == NULL)
errAbort("Can't find targetPcr server for db=%s, target=%s",
db, target);
}
fPrimer = gfPcrMakePrimer(fPrimer);
rPrimer = gfPcrMakePrimer(rPrimer);
if (doPcr(server, targetServer, fPrimer, rPrimer,
maxSize, minPerfect, minGood, flipReverse))
return;
}
doGetPrimers(db, organism, serverList,
fPrimer, rPrimer, maxSize, minPerfect, minGood, flipReverse);
}
void MGHPCCPod::setWorkloadPower(const std::string &rackName, const std::string &serverName,
double cpuPower, double memPower, int usedCPUs)
{
Server *server = findServer(rackName, serverName);
if(!server){
LOG_ERROR << "Server is null.";
return;
}
server->setCpuDynPower(cpuPower);
server->setMemPower(memPower);
server->setUsedCPUs(usedCPUs);
VLOG_2 << "Setting [CPUpower= " << cpuPower << ", memory Power= " << memPower
<< "] of server " << serverName << " of rack " << rackName ;
}
// -----------------------------------------------------------------------------
// StartServer
// Static function to start the server.
// -----------------------------------------------------------------------------
//
static TInt StartServer()
{
TInt result;
TFindServer findServer( KSnsrDispCtrlSrvName );
TFullName name;
result = findServer.Next( name );
if ( result != KErrNone )
{
// Server not running
result = CreateServerProcess();
}
return result;
}
void MGHPCCPod::getWorkloadPower(const std::string &rackName, const std::string &serverName,
double &cpuPower, double &memPower, int &usedCPUs)
{
Server *server = findServer(rackName, serverName);
if(!server){
LOG_ERROR << "Server is null.";
return;
}
cpuPower = server->getCpuDynPower();
memPower = server->getMemPower();
usedCPUs = server->getUsedCPUs();
VLOG_2 << "Getting [CPUpower= " << cpuPower << ", memory Power= " << memPower
<< "], CPUs used=" << usedCPUs << " of server " << serverName
<< " of rack " << rackName ;
}
// -----------------------------------------------------------------------------
// RHssInterface::StartServer()
// Starts the server if it is not already running
// -----------------------------------------------------------------------------
//
TInt RHssInterface::StartServer()
{
TInt res( KErrNone );
// create server - if one of this name does not already exist
TFindServer findServer( KHotSpotDataServerName );
TFullName name;
if ( findServer.Next( name ) != KErrNone ) // we don't exist already
{
RProcess server;
// Create the server process
res = server.Create( KHotSpotServerExe, KNullDesC );
if ( res != KErrNone ) // thread created ok - now start it going
{
return res;
}
// Rendezvous is used to detect server start
TRequestStatus status;
server.Rendezvous( status );
if ( status != KRequestPending )
{
DEBUG1( "StartServer Rendezvous ERROR: %d", status.Int() );
server.Kill( 0 ); // abort startup
}
else
{
server.Resume(); // logon OK - start the server
}
DEBUG( "StartServer wait for start" );
User::WaitForRequest( status ); // wait for start or death
// We can't use the 'exit reason' if the server paniced as this
// is the panic 'reason' and may be '0' which cannot be distinguished
// from KErrNone
res = ( server.ExitType() == EExitPanic ) ? KErrGeneral : status.Int();
// we're no longer interested in the other process
server.Close();
}
return res;
}
int
serverSetName(char_u *name)
{
HWND hwnd = 0;
hwnd = findServer(name);
if (hwnd != 0)
return FALSE;
/* Remember the name */
serverName = vim_strsave(name);
/* Update the message window title */
SetWindowText(message_window, (char *)name);
return TRUE;
}
void CSmodule_AbstractDisplay::connectToServer(const char *serverName)
{
bool beClient = strcmp("",serverName);
server1 = 0;
int cmode=0;
if ((beClient)&&(parentRoot))
{
server1 = findServer(parentRoot, serverName);
cmode = (server1!=0);
}
// make module red if server is not found but requested
if ((beClient)&&(server1==0))
{
CSsetColor(bodyColor, 100,60,60);
CSsetColor(bodySelColor, 120,70,80);
}
else
{
bodyColor = oldBodyColor;
bodySelColor = oldBodySelColor;
}
if (window)
{
if (cmode==0)
{
doDrawWindow = true;
doCallDrawWindow = false;
}
else
{
//window->hide(); FLTK only makes difficulties with window focus
doDrawWindow = false;
doCallDrawWindow = true;
}
}
isClient = (cmode!=0);
requestServerChange = (server1!=0);
}
// ---------------------------------------------------------------------------
// StartServer
// Creates a new process for the server and starts it up.
// ---------------------------------------------------------------------------
//
static TInt StartServer()
{
LOG(_L("[Cm Server]\t StartServer begin"));
TInt result( KErrNone );
// create server - if one of this name does not already exist
TFindServer findServer( KCmServerName );
TFullName name;
if ( findServer.Next( name ) != KErrNone ) // we don't exist already
{
TRequestStatus status( KRequestPending );
RProcess server;
// Create the server process
result = server.Create( KCmServerExe, KNullDesC );
if( result != KErrNone )
{
return result;
}
// Process created successfully
server.Resume(); // start it going
server.Rendezvous( status );
// Wait until the completion of the server creation
// server signals us when it's up
User::WaitForRequest( status );
if( status != KErrNone )
{
server.Close();
return status.Int();
}
// Server created successfully
server.Close(); // we can close the handle to server process now
}
LOG(_L("[Cm Server]\t StartServer end"));
return result;
}
void XmlConfManager::changeFavChan(QString server, QString chanList) {
QDomElement serverElement = findServer(server);
QDomNodeList favList = serverElement.elementsByTagName("favorite");
for (int i = 0; i < favList.size(); i++) {
serverElement.removeChild(favList.item(i));
}
QStringListIterator it(chanList.split(","));
QDomElement chan;
QDomText name;
int i = 0;
while (it.hasNext()) {
chan = confDesc.createElement("favorite");
chan.setAttribute("id", i);
name = confDesc.createTextNode(it.next());
chan.appendChild(name);
serverElement.appendChild(chan);
i += 1;
}
}
TInt CCapabilityTestStep::StartServer()
{
TInt err = KErrNone;
RMutex mutex;
err = mutex.CreateGlobal(KSipServerStarterMutex);
if (err != KErrNone)
{
err = mutex.OpenGlobal(KSipServerStarterMutex);
if (err != KErrNone)
{
return err;
}
}
mutex.Wait();
{
// Protected with a mutex
TFindServer findServer(KSipServerName);
TFullName name;
if (findServer.Next(name) == KErrNone)
{
mutex.Signal();
mutex.Close();
return KErrNone; // Server already running
}
RSemaphore semaphore;
err = semaphore.CreateGlobal(KSipServerSemaphoreName,0);
if (err == KErrNone)
{
err = CreateServerProcess(semaphore);
semaphore.Close();
}
}
mutex.Signal();
mutex.Close();
return err;
}
// ---------------------------------------------------------------------------
// Start server if it isn't running already
// ---------------------------------------------------------------------------
//
TInt RCatalogsPCConnectivityClient::StartServer()
{
// Check if the server is already running
TFindServer findServer( KCatalogsPCConnectivityServerName );
TFullName name;
TInt result = findServer.Next( name );
if ( result == KErrNone )
{
// Server is running
return KErrNone;
}
// Create a semaphore so we can wait while the server starts
RSemaphore semaphore;
result = semaphore.CreateGlobal(
KCatalogsPCConnectivityServerSemaphoreName, 0 );
if ( result != KErrNone )
{
return result;
}
// Create new Engine service process
result = CreateServerProcess();
if ( result != KErrNone )
{
semaphore.Close();
return result;
}
// Wait while the server starts
semaphore.Wait();
// Semaphore has been signaled, close and return
semaphore.Close();
return KErrNone;
}
// Add a new server to our list of known server. If there is
// already a server with that identifier, the value will be
// updated instead. The ip string should be a properly formatted
// IPv4 address.
server_t *TinyREST::addServer(uint8_t id, char *ip, unsigned short port)
{
server_t *srv = findServer(id);
if (srv == NULL) {
if (server_count < MAX_SERVERS) {
srv = &servers[server_count++];
}
}
if (srv != NULL) {
// Update the server structure. We arrange for "hostName" to
// be a print of the IP address, this will be used when
// performing GET request on callbacks.
srv->id = id;
sscanf(ip,"%u.%u.%u.%u",
&srv->ip[0], &srv->ip[1], &srv->ip[2], &srv->ip[3]);
sprintf(srv->hostName, "%u.%u.%u.%u",
srv->ip[0], srv->ip[1], srv->ip[2], srv->ip[3]);
srv->port = port;
}
return srv;
}
TInt CCapabilityTestStep::StartServer()
{
TInt err = KErrNone;
TFindServer findServer(KSipClientResolverServerName);
TFullName name;
if (findServer.Next(name) == KErrNone)
{
return KErrNone; // Server already running
}
RSemaphore semaphore;
err = semaphore.CreateGlobal(KSipClientResolverServerSemaphoreName,0);
if (err != KErrNone)
{
return err;
}
err = CreateServerProcess(semaphore);
semaphore.Close ();
return err;
}
// -----------------------------------------------------------------------------
// MceServerStarter::Start
// -----------------------------------------------------------------------------
//
TInt MceServerStarter::Start ()
{
TInt err = KErrNone;
TFindServer findServer( KMceServerName );
TFullName name;
if ( findServer.Next( name ) == KErrNone)
{
return KErrNone; // Server already running
}
RSemaphore semaphore;
err = semaphore.CreateGlobal( KMceServerSemaphoreName , 0 );
if ( err != KErrNone )
{
return err;
}
err = CreateServerProcess( semaphore );
semaphore.Close ();
return err;
}
void askForSeq(char *organism, char *db)
/* Put up a little form that asks for sequence.
* Call self.... */
{
struct serverTable *serve = NULL;
/* JavaScript to update form when org changes */
char *onChangeText = "onchange=\""
"document.mainForm.changeInfo.value='orgChange';"
"document.mainForm.submit();\"";
char *userSeq = NULL;
serve = findServer(db, FALSE);
printf(
"<FORM ACTION=\"../cgi-bin/hgBlat\" METHOD=\"POST\" ENCTYPE=\"multipart/form-data\" NAME=\"mainForm\">\n"
"<H2>BLAT Search Genome</H2>\n");
cartSaveSession(cart);
puts("\n");
puts("<INPUT TYPE=HIDDEN NAME=changeInfo VALUE=\"\">\n");
puts("<TABLE BORDER=0 WIDTH=80>\n<TR>\n");
printf("<TD ALIGN=CENTER>Genome:</TD>");
printf("<TD ALIGN=CENTER>Assembly:</TD>");
printf("<TD ALIGN=CENTER>Query type:</TD>");
printf("<TD ALIGN=CENTER>Sort output:</TD>");
printf("<TD ALIGN=CENTER>Output type:</TD>");
printf("<TD ALIGN=CENTER> </TD>");
printf("</TR>\n<TR>\n");
printf("<TD ALIGN=CENTER>\n");
printBlatGenomeListHtml(db, onChangeText);
printf("</TD>\n");
printf("<TD ALIGN=CENTER>\n");
printBlatAssemblyListHtml(db);
printf("</TD>\n");
printf("<TD ALIGN=CENTER>\n");
cgiMakeDropList("type", typeList, ArraySize(typeList), NULL);
printf("</TD>\n");
printf("<TD ALIGN=CENTER>\n");
cgiMakeDropList("sort", sortList, ArraySize(sortList), cartOptionalString(cart, "sort"));
printf("</TD>\n");
printf("<TD ALIGN=CENTER>\n");
cgiMakeDropList("output", outputList, ArraySize(outputList), cartOptionalString(cart, "output"));
printf("</TD>\n");
printf("</TR>\n<TR>\n");
userSeq = cartUsualString(cart, "userSeq", "");
printf("<TD COLSPAN=5 ALIGN=CENTER>\n");
printf("<TEXTAREA NAME=userSeq ROWS=14 COLS=80>%s</TEXTAREA>\n", userSeq);
printf("</TD>\n");
printf("</TR>\n<TR>\n");
printf("<TD COLSPAN=5 ALIGN=CENTER>\n");
printf("<INPUT TYPE=SUBMIT NAME=Submit VALUE=submit>\n");
printf("<INPUT TYPE=SUBMIT NAME=Lucky VALUE=\"I'm feeling lucky\">\n");
printf("<INPUT TYPE=SUBMIT NAME=Clear VALUE=clear>\n");
printf("</TD>\n");
printf("</TR>\n<TR>\n");
puts("<TD COLSPAN=5 WIDTH=\"100%\">\n"
"Paste in a query sequence to find its location in the\n"
"the genome. Multiple sequences may be searched \n"
"if separated by lines starting with '>' followed by the sequence name.\n"
"</TD>\n"
"</TR>\n"
);
puts("<TR><TD COLSPAN=5 WIDTH=\"100%\">\n");
puts("<BR><B>File Upload:</B> ");
puts("Rather than pasting a sequence, you can choose to upload a text file containing "
"the sequence.<BR>");
puts("Upload sequence: <INPUT TYPE=FILE NAME=\"seqFile\">");
puts(" <INPUT TYPE=SUBMIT Name=Submit VALUE=\"submit file\"><P>\n");
printf("%s",
"<P>Only DNA sequences of 25,000 or fewer bases and protein or translated \n"
"sequence of 10000 or fewer letters will be processed. Up to 25 sequences\n"
"can be submitted at the same time. The total limit for multiple sequence\n"
"submissions is 50,000 bases or 25,000 letters.\n</P>");
if (hgPcrOk(db))
printf("<P>For locating PCR primers, use <A HREF=\"../cgi-bin/hgPcr?db=%s\">In-Silico PCR</A>"
" for best results instead of BLAT.</P>", db);
puts("</TD></TR></TABLE>\n");
printf("</FORM>\n");
webNewSection("About BLAT");
printf(
"<P>BLAT on DNA is designed to\n"
"quickly find sequences of 95%% and greater similarity of length 25 bases or\n"
"more. It may miss more divergent or shorter sequence alignments. It will find\n"
"perfect sequence matches of 20 bases.\n"
"BLAT on proteins finds sequences of 80%% and greater similarity of length 20 amino\n"
"acids or more. In practice DNA BLAT works well on primates, and protein\n"
"blat on land vertebrates."
);
printf("%s",
"\n</P><P>BLAT is not BLAST. DNA BLAT works by keeping an index of the entire genome\n"
"in memory. The index consists of all overlapping 11-mers stepping by 5 except for\n"
"those heavily involved in repeats. The index takes up about\n"
"2 gigabytes of RAM. RAM can be further reduced to less than 1 GB by increasing step size to 11.\n"
"The genome itself is not kept in memory, allowing\n"
"BLAT to deliver high performance on a reasonably priced Linux box.\n"
"The index is used to find areas of probable homology, which are then\n"
"loaded into memory for a detailed alignment. Protein BLAT works in a similar\n"
"manner, except with 4-mers rather than 11-mers. The protein index takes a little\n"
"more than 2 gigabytes.</P>\n"
"<P>BLAT was written by <A HREF=\"mailto:[email protected]\">Jim Kent</A>.\n"
"Like most of Jim's software, interactive use on this web server is free to all.\n"
"Sources and executables to run batch jobs on your own server are available free\n"
"for academic, personal, and non-profit purposes. Non-exclusive commercial\n"
"licenses are also available. See the \n"
"<A HREF=\"http://www.kentinformatics.com\" TARGET=_blank>Kent Informatics</A>\n"
"website for details.</P>\n"
"\n"
"<P>For more information on the graphical version of BLAT, click the Help \n"
"button on the top menu bar");
if (hIsGsidServer())
printf(". </P> \n");
else
printf(" or see the Genome Browser <A HREF=\"../FAQ/FAQblat.html\">FAQ</A>. </P> \n");
}
void blatSeq(char *userSeq, char *organism)
/* Blat sequence user pasted in. */
{
FILE *f;
struct dnaSeq *seqList = NULL, *seq;
struct tempName pslTn, faTn;
int maxSingleSize, maxTotalSize, maxSeqCount;
int minSingleSize = minMatchShown;
char *genome, *db;
char *type = cgiString("type");
char *seqLetters = cloneString(userSeq);
struct serverTable *serve;
int conn;
int oneSize, totalSize = 0, seqCount = 0;
boolean isTx = FALSE;
boolean isTxTx = FALSE;
boolean txTxBoth = FALSE;
struct gfOutput *gvo;
boolean qIsProt = FALSE;
enum gfType qType, tType;
struct hash *tFileCache = gfFileCacheNew();
boolean feelingLucky = cgiBoolean("Lucky");
getDbAndGenome(cart, &db, &genome, oldVars);
if(!feelingLucky)
cartWebStart(cart, db, "%s BLAT Results", trackHubSkipHubName(organism));
/* Load user sequence and figure out if it is DNA or protein. */
if (sameWord(type, "DNA"))
{
seqList = faSeqListFromMemText(seqLetters, TRUE);
uToT(seqList);
isTx = FALSE;
}
else if (sameWord(type, "translated RNA") || sameWord(type, "translated DNA"))
{
seqList = faSeqListFromMemText(seqLetters, TRUE);
uToT(seqList);
isTx = TRUE;
isTxTx = TRUE;
txTxBoth = sameWord(type, "translated DNA");
}
else if (sameWord(type, "protein"))
{
seqList = faSeqListFromMemText(seqLetters, FALSE);
isTx = TRUE;
qIsProt = TRUE;
}
else
{
seqList = faSeqListFromMemTextRaw(seqLetters);
isTx = !seqIsDna(seqList);
if (!isTx)
{
for (seq = seqList; seq != NULL; seq = seq->next)
{
seq->size = dnaFilteredSize(seq->dna);
dnaFilter(seq->dna, seq->dna);
toLowerN(seq->dna, seq->size);
subChar(seq->dna, 'u', 't');
}
}
else
{
for (seq = seqList; seq != NULL; seq = seq->next)
{
seq->size = aaFilteredSize(seq->dna);
aaFilter(seq->dna, seq->dna);
toUpperN(seq->dna, seq->size);
}
qIsProt = TRUE;
}
}
if (seqList != NULL && seqList->name[0] == 0)
{
freeMem(seqList->name);
seqList->name = cloneString("YourSeq");
}
trimUniq(seqList);
/* If feeling lucky only do the first on. */
if(feelingLucky && seqList != NULL)
{
seqList->next = NULL;
}
/* Figure out size allowed. */
maxSingleSize = (isTx ? 10000 : 75000);
maxTotalSize = maxSingleSize * 2.5;
#ifdef LOWELAB
maxSeqCount = 200;
#else
maxSeqCount = 25;
#endif
/* Create temporary file to store sequence. */
trashDirFile(&faTn, "hgSs", "hgSs", ".fa");
faWriteAll(faTn.forCgi, seqList);
/* Create a temporary .psl file with the alignments against genome. */
trashDirFile(&pslTn, "hgSs", "hgSs", ".pslx");
f = mustOpen(pslTn.forCgi, "w");
gvo = gfOutputPsl(0, qIsProt, FALSE, f, FALSE, TRUE);
serve = findServer(db, isTx);
/* Write header for extended (possibly protein) psl file. */
if (isTx)
{
if (isTxTx)
{
qType = gftDnaX;
tType = gftDnaX;
}
else
{
qType = gftProt;
tType = gftDnaX;
}
}
else
{
qType = gftDna;
tType = gftDna;
}
pslxWriteHead(f, qType, tType);
if (qType == gftProt)
{
minSingleSize = 14;
}
else if (qType == gftDnaX)
{
minSingleSize = 36;
}
/* Loop through each sequence. */
for (seq = seqList; seq != NULL; seq = seq->next)
{
printf(" "); fflush(stdout); /* prevent apache cgi timeout by outputting something */
oneSize = realSeqSize(seq, !isTx);
if ((seqCount&1) == 0) // Call bot delay every 2nd time starting with first time
hgBotDelay();
if (++seqCount > maxSeqCount)
{
warn("More than 25 input sequences, stopping at %s.",
seq->name);
break;
}
if (oneSize > maxSingleSize)
{
warn("Sequence %s is %d letters long (max is %d), skipping",
seq->name, oneSize, maxSingleSize);
continue;
}
if (oneSize < minSingleSize)
{
warn("Warning: Sequence %s is only %d letters long (%d is the recommended minimum)",
seq->name, oneSize, minSingleSize);
// we could use "continue;" here to actually enforce skipping,
// but let's give the short sequence a chance, it might work.
// minimum possible length = tileSize+stepSize, so mpl=16 for dna stepSize=5, mpl=10 for protein.
if (qIsProt && oneSize < 1) // protein does not tolerate oneSize==0
continue;
}
totalSize += oneSize;
if (totalSize > maxTotalSize)
{
warn("Sequence %s would take us over the %d letter limit, stopping here.",
seq->name, maxTotalSize);
break;
}
conn = gfConnect(serve->host, serve->port);
if (isTx)
{
gvo->reportTargetStrand = TRUE;
if (isTxTx)
{
gfAlignTransTrans(&conn, serve->nibDir, seq, FALSE, 5,
tFileCache, gvo, !txTxBoth);
if (txTxBoth)
{
reverseComplement(seq->dna, seq->size);
conn = gfConnect(serve->host, serve->port);
gfAlignTransTrans(&conn, serve->nibDir, seq, TRUE, 5,
tFileCache, gvo, FALSE);
}
}
else
{
gfAlignTrans(&conn, serve->nibDir, seq, 5, tFileCache, gvo);
}
}
else
{
gfAlignStrand(&conn, serve->nibDir, seq, FALSE, minMatchShown, tFileCache, gvo);
reverseComplement(seq->dna, seq->size);
conn = gfConnect(serve->host, serve->port);
gfAlignStrand(&conn, serve->nibDir, seq, TRUE, minMatchShown, tFileCache, gvo);
}
gfOutputQuery(gvo, f);
}
carefulClose(&f);
showAliPlaces(pslTn.forCgi, faTn.forCgi, serve->db, qType, tType,
organism, feelingLucky);
if(!feelingLucky)
cartWebEnd();
gfFileCacheFree(&tFileCache);
}
HDDEDATA gcDDEManager::processCallBack(WORD wType, WORD wFmt, HCONV hConv, HSZ hsz1, HSZ hsz2, HDDEDATA hData, DWORD lData1, DWORD lData2)
{
//printf("\tProcessing msg: %d\n", wType);
switch (wType)
{
case XTYP_CONNECT:
{
char szTopic[255];
stringFromAtom(hsz1, szTopic, 255);
char szServer[255];
stringFromAtom(hsz2, szServer, 255);
gcDDEServer *server = findServer(szServer);
if (server)
return server->acceptConnection(szTopic, hConv);
break;
}
case XTYP_CONNECT_CONFIRM:
{
if (m_pCurConnecting)
{
m_pCurConnecting->setConv(hConv);
m_pCurConnecting = NULL;
return (DDERETURN)(DWORD)true;
}
break;
}
case XTYP_DISCONNECT:
{
gcDDEConnection *connection = findConnection(hConv);
if (connection)
return connection->disconnect();
break;
}
case XTYP_POKE:
{
gcDDEConnection *connection = findConnection(hConv);
if (connection)
return (DDERETURN)connection->handlePoke(hsz2, hData);
else
return (DDERETURN)DDE_FNOTPROCESSED;
}
case XTYP_ADVSTART:
case XTYP_ADVSTOP:
case XTYP_EXECUTE:
case XTYP_REQUEST:
case XTYP_ADVREQ:
case XTYP_ADVDATA:
printf("gcDDE: This method not implemented! [%d]", wType);
}
return (DDERETURN)0;
}
void CWatchdog::Start()
{
PRINT(_L("CWatchdog::Start()"));
// Double check that harvester server is not already running
TFullName name;
TInt res( KErrNone );
// find really Harvester Server, using TFindServer to avoid logon a dead process
TFindServer findServer( KHarvesterServerProcess );
if ( findServer.Next(name) == KErrNone )
{
TFindProcess findProcess( KHarvesterServerProcess );
if ( findProcess.Next(name) == KErrNone )
{
PRINT(_L("CWatchdog::Start() - server already running, start listening"));
iProcess.Close();
res = iProcess.Open(name);
if ( res != KErrNone )
{
PRINT(_L("CWatchdog::Start() - error in starting listening "));
return;
}
iState = EWaitingRendezvous;
SetActive();
return;
}
}
// close the panic process
TFindProcess findProcess( KHarvesterServerProcess );
if ( findProcess.Next(name) == KErrNone )
{
iProcess.Close();
}
// Create the server process
// KNullDesC param causes server's E32Main() to be run
res = iProcess.Create( KHarvesterServerExe, KNullDesC );
if ( res != KErrNone )
{
PRINT(_L("CWatchdog::ConstructL() - error in server creation"));
return;
}
// start process and wait until it is constructed
iProcess.Rendezvous(iStatus);
if( iStatus != KRequestPending )
{
iProcess.Kill( 0 ); // abort startup
}
else
{
iProcess.Resume(); // logon OK - start the server
iState = EWaitingRendezvous;
SetActive();
}
PRINT(_L("CWatchdog::ConstructL() - Start end"));
}
//----------------------------------------
void GenericAPICore::process()
//----------------------------------------
{
GenericRequest *req;
GenericResponse *res;
if (!m_suspended)
{
// Process timeout on pending requests
while((m_outCount > 0) && ((req = m_outboundQueue.front().first)->getTimeout() <= time(NULL)))
{
--m_outCount;
res = m_outboundQueue.front().second;
m_outboundQueue.pop();
responseCallback(res);
delete res;
delete req;
}
// Process timeout on pending responses
while((m_pendingCount > 0) && ((res = (*m_pending.begin()).second)->getTimeout() <= time(NULL)))
{
--m_pendingCount;
m_pending.erase(m_pending.begin());
responseCallback(res);
delete res;
}
while(m_outCount > 0)
{
pair<GenericRequest *, GenericResponse *> out_pair = m_outboundQueue.front();
req = out_pair.first;
res = out_pair.second;
GenericConnection *con = NULL;
if (req->getMappedServerTrack() == 0) // request has no originating "owner" server
{
con = getNextActiveConnection(); // it does not matter which server we send this to
}
else
{
ServerTrackObject *stobj = findServer(req->getMappedServerTrack());
if (stobj)
{
con = stobj->getConnection(); // the server connection to respond to
req->setServerTrack(stobj->getRealServerTrack()); // map server track back to REAL server track
//printf("\nUnmapping %d to %d", stobj->getMappedServerTrack(), req->getMappedServerTrack()); //debug
delete stobj;
}
}
if (con != NULL)
{
Base::ByteStream msg;
req->pack(msg);
con->Send(msg);
m_pending.insert(pair<unsigned, GenericResponse *>(res->getTrack(), res));
--m_outCount;
++m_pendingCount;
m_outboundQueue.pop();
delete req;
}
else
{
//no active connections
break; //from while loop
}
}
}
for (std::vector<GenericConnection *>::iterator conIter = m_serverConnections.begin(); conIter != m_serverConnections.end(); conIter++)
{
GenericConnection *con = *conIter;
con->process();
}
}
EXPORT_C void StartServerL(const TDesC& aServerName, TUid aServerUid3, const TDesC& aServerFileName)
#endif
{
CALLSTACKITEM_N(_CL(""), _CL("StartServer"));
TBuf<50> mutexname; MakeServerMutexName(mutexname, aServerName);
RAMutex mutex; mutex.GlobalLA(mutexname);
TFindServer findServer(aServerName);
TFullName name;
if (findServer.Next(name) == KErrNone)
{
return;
}
#if defined(__WINS__)
RAThread serverthread;
#else
RAProcess serverthread;
#endif
TBuf<50> semaphorename; MakeServerSemaphoreName(semaphorename, aServerName);
RSemaphore semaphore;
if (semaphore.CreateGlobal(semaphorename, 0)!=KErrNone) {
User::LeaveIfError(semaphore.OpenGlobal(semaphorename));
}
#if defined(__WINS__)
CreateServerProcessLA(aServerName, aFunction, serverthread);
#else
CreateServerProcessLA(aServerName, aServerUid3, aServerFileName, serverthread);
#endif
TTimeIntervalMicroSeconds32 w(10*1000);
TInt i=0;
TInt result=KErrTimedOut;
while (i < 17) {
// a couple of minutes, in case there's some db conversion or the like
#ifdef __S60V3__
if (semaphore.Wait(w.Int())==KErrNone) {
#else
if ( semaphore.Count()>0) {
#endif
result=KErrNone;
break;
}
TExitType etype=serverthread.ExitType();
if (etype!=EExitPending) {
// server died
result=KErrServerTerminated;
break;
}
#ifndef __S60V3__
User::After(w);
#endif
w=w.Int()*2;
i++;
}
if (result!=KErrNone) {
User::Leave(result);
}
semaphore.Close();
}
#if defined(__WINS__)
void CreateServerProcessLA(const TDesC& aServerName, TThreadFunction aFunction,
RAThread& aThreadInto)
#else
# if defined(__WINS__)
void CreateServerProcessLA(const TDesC& aServerName, TUid aServerUid3,
const TDesC& aServerFileName,
RAThread& aThreadInto)
# else
void CreateServerProcessLA(const TDesC& aServerName, TUid aServerUid3,
const TDesC& aServerFileName,
RAProcess& aThreadInto)
# endif
#endif
{
CALLSTACKITEM_N(_CL(""), _CL("CreateServerProcess"));
TInt result;
#if defined(__WINS__)
//# if !defined(EKA2)
#if 0
const TUidType serverUid(KNullUid, KNullUid, aServerUid3);
RLibrary lib;
TInt err=lib.Load(aServerFileName, _L("z:\\system\\programs"), serverUid);
if (err!=KErrNone) {
err=lib.Load(aServerFileName);
}
User::LeaveIfError(err);
// Get the WinsMain function
TLibraryFunction functionWinsMain = lib.Lookup(1);
// Call it and cast the result to a thread function
TThreadFunction serverThreadFunction = reinterpret_cast<TThreadFunction>(functionWinsMain());
# else
TThreadFunction serverThreadFunction = aFunction;
# endif
TName threadName(aServerName);
// Append a random number to make it unique
threadName.AppendNum(Math::Random(), EHex);
# if 0
//# if !defined(EKA2)
aThreadInto.CreateLA(threadName, // create new server thread
serverThreadFunction, // thread's main function
KDefaultStackSize,
NULL, // parameters
&lib,
NULL,
KServerMinHeapSize,
KServerMaxHeapSize,
EOwnerProcess);
lib.Close(); // if successful, server thread has handle to library now
# else
aThreadInto.CreateLA(threadName, serverThreadFunction,
KDefaultStackSize,
KServerMinHeapSize, KServerMaxHeapSize, 0, EOwnerProcess);
# endif
aThreadInto.SetPriority(EPriorityMore);
#else
const TUidType serverUid(KNullUid, KNullUid, aServerUid3);
aThreadInto.CreateLA(aServerFileName, _L(""), serverUid);
#endif
aThreadInto.Resume();
}
