void FramedReader::onNextImpl(std::unique_ptr<folly::IOBuf> payload) noexcept {
streamRequested_ = false;
if (payload) {
payloadQueue_.append(std::move(payload));
parseFrames();
}
requestStream();
}
/** FIXME
* This will take the input and behave like the same from the client
* This will call the appropriate action function for the server or return error etc
* FIXME there's a lot to do here!!!!!
*/
string MessagingServer::processRequest(string request){
stringstream requestStream(request);
string messageString = "";
requestStream >> enteredCommand;
if(enteredCommand == ""){
messageString = "";
if(debug) // FIXME all these debugging errors might need to always display -ask
cout << "error INCORRECT REQUEST COMMAND FORMATTING 1\n";
}else if(enteredCommand == "put"){
if(debug)
cout << "put!\n"; // TODO remove these later
bool success = addNewMessage(requestStream);
if(success)
messageString = "OK";
else
if(debug)
cout << "error INCORRECT REQUEST FORMATTING\n";
}else if(enteredCommand == "list"){
if(debug)
cout << "list!\n"; // TODO remove these later
messageString = getMessageListForUser(requestStream);
if(messageString == "")
if(debug)
cout << "error INCORRECT REQUEST FORMATTING\n";
}else if(enteredCommand == "get"){
if(debug)
cout << "get!\n"; // TODO remove these later
messageString = getMessage(requestStream);
if(messageString == "")
if(debug)
cout << "error INCORRECT REQUEST FORMATTING\n";
}else if(enteredCommand == "reset"){ // if quit is followed by other characters TODO need to test
if(debug)
cout << "reset!\n"; // TODO remove these later
bool success = eraseAllMessages(requestStream);
if(success)
messageString = "OK";
else
if(debug)
cout << "error INCORRECT REQUEST FORMATTING\n";
}else{
messageString = "";
if(debug)
cout << "error INCORRECT REQUEST COMMAND FORMATTING 2\n";
}
// TODO make a universal close of stringStream!!! If I need to?
if(enteredCommand == "get")
return messageString;
else return messageString + "\n";
}
void Client::openFile(std::string const& t_path)
{
m_sourceFile.open(t_path, std::ios_base::binary | std::ios_base::ate);
if (m_sourceFile.fail())
throw std::fstream::failure("Failed while opening file " + t_path);
m_sourceFile.seekg(0, m_sourceFile.end);
auto fileSize = m_sourceFile.tellg();
m_sourceFile.seekg(0, m_sourceFile.beg);
std::ostream requestStream(&m_request);
boost::filesystem::path p(t_path);
requestStream << p.filename().string() << "\n" << fileSize << "\n\n";
BOOST_LOG_TRIVIAL(trace) << "Request size: " << m_request.size();
}
/**
* Checks to see if the input stream is a put request,
* if so it reads in the length of the message to be send and continues to recieve
* until the entire message has been recieved
* @param int client socket indentifier
* @param string the request string recieved so far -this string is appended if it's a put request
* @return bool if the request is a put request
*/
bool MessagingServer::finishReadingIfPutRequest(int client, string &request){
stringstream requestStream(request);
string tempCommand = "", tempUser = "", tempSubject = "", tempLength = "", tempMessage = "", tempStr = "";
if(!(requestStream >> tempCommand)) // leave error checking to later functions
return false;
if(tempCommand != "put") // verification is only needed for put requests TODO
return false;
if(!(requestStream >> tempUser))
return false;
if(!(requestStream >> tempSubject))
return false;
if(!(getline(requestStream, tempLength)))
return false;
while(getline(requestStream, tempStr)){ // get entire message up to this point
tempMessage += tempStr;
tempMessage += "\n";
}
int recievedMessageLength = atoi(tempLength.c_str());
if(recievedMessageLength >= 0 && tempMessage.length() < recievedMessageLength){
string newMessagePart = "";
while ((tempMessage.length() + newMessagePart.length()) < recievedMessageLength) {
int nread = recv(client,buf_,1024,0);
if (nread < 0) {
if (errno == EINTR)
// the socket call was interrupted -- try again
continue;
else
// an error occurred, so break out
return false;
} else if (nread == 0) {
// the socket is closed
return false;
}
// be sure to use append in case we have binary data
newMessagePart.append(buf_,nread);
}
request += newMessagePart;
return true;
}else{
return false; // leave error handling for other functions TODO
}
}
void GPUdb::submitRequestRaw(const std::string& endpoint, const std::vector<uint8_t>& request, GpudbResponse& response, const bool enableCompression) const
{
try
{
boost::asio::io_service ioService;
boost::asio::ip::tcp::resolver resolver(ioService);
boost::asio::ip::tcp::resolver::query query(host, service);
boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
boost::asio::ip::tcp::socket socket(ioService);
boost::asio::connect(socket, iterator);
boost::asio::streambuf requestStreamBuffer;
std::ostream requestStream(&requestStreamBuffer);
requestStream << "POST " << path << endpoint << " HTTP/1.0\r\n";
if (!authorization.empty())
{
requestStream << "Authorization: Basic " << authorization << "\r\n";
}
if (enableCompression && useSnappy)
{
std::string compressedRequest;
snappy::Compress((char*)&request[0], request.size(), &compressedRequest);
requestStream << "Content-Type: application/x-snappy\r\n";
requestStream << "Content-Length: " << compressedRequest.size() << "\r\n";
requestStream << "\r\n";
boost::asio::write(socket, requestStreamBuffer);
boost::asio::write(socket, boost::asio::buffer(compressedRequest));
}
else
{
requestStream << "Content-Type: application/octet-stream\r\n";
requestStream << "Content-Length: " << request.size() << "\r\n";
requestStream << "\r\n";
boost::asio::write(socket, requestStreamBuffer);
boost::asio::write(socket, boost::asio::buffer(request));
}
boost::asio::streambuf responseStreamBuffer;
boost::asio::read_until(socket, responseStreamBuffer, "\r\n\r\n");
std::istream responseStream(&responseStreamBuffer);
std::string header;
std::getline(responseStream, header);
if (!responseStream || header.substr(0, 5) != "HTTP/")
{
throw GPUdbException("Invalid response from server.");
}
do
{
std::getline(responseStream, header);
}
while (header != "\r");
std::vector<uint8_t> responseBytes;
boost::system::error_code error;
do
{
boost::asio::streambuf::const_buffers_type data = responseStreamBuffer.data();
size_t totalRead = 0;
for (boost::asio::streambuf::const_buffers_type::const_iterator it = data.begin(); it != data.end(); ++it)
{
const uint8_t* buffer = boost::asio::buffer_cast<const uint8_t*>(*it);
size_t read = boost::asio::buffer_size(*it);
responseBytes.insert(responseBytes.end(), buffer, buffer + read);
totalRead += read;
}
responseStreamBuffer.consume(totalRead);
}
while (boost::asio::read(socket, responseStreamBuffer, boost::asio::transfer_at_least(1), error));
if (error != boost::asio::error::eof)
{
throw boost::system::system_error(error);
}
avro::decode(response, responseBytes);
if (response.status == "ERROR")
{
throw GPUdbException(response.message);
}
}
catch (const boost::system::system_error& ex)
{
throw GPUdbException(std::string(ex.what()));
}
}
void FramedReader::requestImpl(size_t n) noexcept {
allowance_.release(n);
parseFrames();
requestStream();
}
/**
* "dgemv T/N alpha pathToA Y/N pathToX Y/N pathToY Y/N"
* Y = alpha* op(A) * X
*/
bool dgemv (char* request) {
/* 0. Chomp out the new line character */
chomp (request);
/* 1. Parse and figure out all the parameters */
int requestCount = 0;
std::string requestArray[9];
std::stringstream requestStream(request);
while (getline(requestStream, requestArray[requestCount++], ' '));
if (9 != (requestCount-1)) {
fprintf (stderr, "There are fewer than 9 arguments! (%d)\n", requestCount);
return false;
}
/* Get the alpha */
const double alpha = atof (requestArray[2].c_str());
/* 2. Load A and X into memory */
if (false == loadGlobal (requestArray[3])) return false;
if (false == loadGlobal (requestArray[5])) return false;
/* 3. Perform the requested operation */
/* 3.0 Get all the required matrices */
dist_matrix_t* A = (dist_dataset_map.find (requestArray[3]))->second;
dist_matrix_t* X = (dist_dataset_map.find (requestArray[5]))->second;
/* 3.1 Make sure that X is a column vector */
if (1 != X->Width()) {
fprintf (stderr, "X is not a column vector (%d,%d)\n",
X->Height(), X->Width());
return false;
}
/* 3.2 Make sure that A and X match up */
if (0 == requestArray[1].compare("T") && A->Height() != X->Height()) {
fprintf (stderr, "Dimensions of A' and X don't match (%d,%d)x(%d)",
A->Width(), A->Height(), X->Height());
return false;
} else if (0 != requestArray[1].compare("T") && A->Width() != X->Height()) {
fprintf (stderr, "Dimensions of A and X don't match (%d,%d)x(%d)",
A->Height(), A->Width(), X->Height());
return false;
}
/* 3.3 Reserve space for Y */
if (false == reserveGlobal (requestArray[7],
(0==(requestArray[1].compare("T"))?A->Width(): A->Height()),
1))
return false;
dist_matrix_t* Y = (dist_dataset_map.find (requestArray[7]))->second;
/* 3.3 Compute what is needed */
elem::Gemv ((0==(requestArray[1].compare("T"))?
elem::TRANSPOSE : elem::NORMAL),
alpha,
(*A),
(*X),
0.0,
(*Y));
/* 5. Cache things that are needed */
if (0 != requestArray[4].compare("Y"))
if (false == unloadGlobal (requestArray[3])) return false;
if (0 != requestArray[6].compare("Y"))
if (false == unloadGlobal (requestArray[5])) return false;
if (0 != requestArray[8].compare("Y")) {
if (false == flushGlobal (requestArray[7])) return false;
}
return true;
}
int main( int argc, char * argv[] )
{
if( argc != 6 ){
std::cerr << "Usage: " << argv[0] << " host file proxy_host proxt_port authorization" << std::endl;
return 1;
}
std::string const host = argv[1];
std::string const file = argv[2];
std::string const proxyHost = argv[3];
std::string const proxyPort = argv[4];
std::string const authorization = argv[5];
asio::io_service io_service;
asio::ip::tcp::resolver resolver( io_service );
asio::ip::tcp::resolver::query const query( proxyHost, proxyPort );
asio::ip::tcp::resolver::iterator endpointIterator = resolver.resolve( query );
asio::ip::tcp::socket socket( io_service );
asio::connect( socket, endpointIterator );
asio::streambuf requestBuffer;
std::ostream requestStream( & requestBuffer );
requestStream << "GET " << host << "/" << file << " HTTP/1.0\r\n";
requestStream << "Host: " << host << "\r\n";
requestStream << "Accept: */*\r\n";
if( authorization != "" ){
requestStream << "Proxy-Authorization: Basic " << authorization << "\n\r";
}
requestStream << "Connection: close\r\n\r\n";
asio::write( socket, requestBuffer );
asio::streambuf response_buffer;
std::istream responseStream( & response_buffer );
asio::read_until( socket, response_buffer, "\r\n");
std::string httpVersion;
responseStream >> httpVersion;
unsigned status_code;
responseStream >> status_code;
std::string status_message;
std::getline( responseStream, status_message );
if( ! responseStream || httpVersion.substr( 0, 5 ) != "HTTP/" )
{
std::cerr << "Invalid response\n";
return 2;
}
if( status_code != 200 )
{
std::cerr << "Response returned with status code " << status_code << "\n";
return 3;
}
asio::read_until( socket, response_buffer, "\r\n\r\n" );
std::string header;
while( std::getline( responseStream, header ) && header != "\r" ){
std::cout << "> " << header << "\n";
}
std::cout << std::endl;
boost::system::error_code error;
while( asio::read( socket, response_buffer, asio::transfer_at_least( 1 ), error ) ){
std::cout << & response_buffer;
}
if( error != asio::error::eof ){
std::cerr << boost::system::system_error( error ).what() << "\n";
return 4;
}
return 0;
}
int eMoviePlayer::playStream(eString mrl)
{
int apid = -1, vpid = -1, ac3 = -1;
// receive video stream from VLC on PC
eDebug("[MOVIEPLAYER] start playing stream...");
status.BUFFERFILLED = false;
pthread_mutex_lock(&mutex);
tsBuffer.clear();
pthread_mutex_unlock(&mutex);
if (requestStream() < 0)
{
eDebug("[MOVIEPLAYER] requesting stream failed...");
close(fd);
return -1;
}
int ibuff;
if(status.PLG)
ibuff = initialBuffer;
else
ibuff = INITIALBUFFER;
if (bufferStream(fd, ibuff) == 0)
{
eDebug("[MOVIEPLAYER] buffer is empty.");
close(fd);
if (cancelBuffering > 0)
return 0;
else
return -4;
}
status.BUFFERFILLED = true;
find_avpids(&tsBuffer, &vpid, &apid, &ac3);
if (vpid == -1 || apid == -1)
{
if(status.NSF ) // plugin can playback file without A or V too
{
eDebug("[MOVIEPLAYER] both AV pids not found: vpid %d apid %d, but play.",vpid,apid);
}
else
{
eDebug("[MOVIEPLAYER] no AV pids found.");
close(fd);
return -5;
}
}
status.NSF=false;
status.AVPIDS_FOUND = true;
if(!status.DVB)
stopDVB();
Decoder::setMpegDevice(-1);
// set pids
Decoder::parms.vpid = vpid;
Decoder::parms.apid = apid;
Decoder::parms.audio_type = DECODE_AUDIO_MPEG;
int ac3default = 0;
eConfig::getInstance()->getKey("/elitedvb/audio/ac3default", ac3default);
if (ac3 && ac3default)
{
if (mrl.right(3) == "vob" || mrl.left(3) == "dvd")
Decoder::parms.audio_type = DECODE_AUDIO_AC3_VOB;
else
Decoder::parms.audio_type = DECODE_AUDIO_AC3;
}
eZapMain::getInstance()->hideInfobar();
usleep(100000);
Decoder::SetStreamType(TYPE_PES);
Decoder::Set();
#ifndef DISABLE_LCD
unsigned int pos = mrl.find_last_of('/');
eZapLCD::getInstance()->lcdMain->ServiceName->setText(mrl.right(mrl.size() - pos - 1));
#endif
createThreads();
status.ACTIVE = true;
return 0;
}
