status_t
NodeManager::Init(BRect videoBounds, float videoFrameRate,
color_space preferredVideoFormat, float audioFrameRate,
uint32 audioChannels, int32 loopingMode, bool loopingEnabled,
float speed, uint32 enabledNodes, bool useOverlays)
{
// init base class
PlaybackManager::Init(videoFrameRate, true, loopingMode, loopingEnabled,
speed);
// get some objects from a derived class
if (fVideoTarget == NULL)
fVideoTarget = CreateVideoTarget();
if (fVideoSupplier == NULL)
fVideoSupplier = CreateVideoSupplier();
if (fAudioSupplier == NULL)
fAudioSupplier = CreateAudioSupplier();
return FormatChanged(videoBounds, videoFrameRate, preferredVideoFormat,
audioFrameRate, audioChannels, enabledNodes, useOverlays, true);
}
status_t
BBufferConsumer::HandleMessage(int32 message, const void* data, size_t size)
{
PRINT(4, "BBufferConsumer::HandleMessage %#lx, node %ld\n", message, ID());
status_t rv;
switch (message) {
case CONSUMER_ACCEPT_FORMAT:
{
const consumer_accept_format_request* request
= static_cast<const consumer_accept_format_request*>(data);
consumer_accept_format_reply reply;
reply.format = request->format;
status_t status = AcceptFormat(request->dest, &reply.format);
request->SendReply(status, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_GET_NEXT_INPUT:
{
const consumer_get_next_input_request *request = static_cast<const consumer_get_next_input_request *>(data);
consumer_get_next_input_reply reply;
reply.cookie = request->cookie;
rv = GetNextInput(&reply.cookie, &reply.input);
request->SendReply(rv, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_DISPOSE_INPUT_COOKIE:
{
const consumer_dispose_input_cookie_request *request = static_cast<const consumer_dispose_input_cookie_request *>(data);
consumer_dispose_input_cookie_reply reply;
DisposeInputCookie(request->cookie);
request->SendReply(B_OK, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_BUFFER_RECEIVED:
{
const consumer_buffer_received_command* command
= static_cast<const consumer_buffer_received_command*>(data);
BBuffer* buffer = fBufferCache->GetBuffer(command->buffer);
if (buffer == NULL) {
ERROR("BBufferConsumer::CONSUMER_BUFFER_RECEIVED can't"
"find the buffer\n");
} else {
buffer->SetHeader(&command->header);
PRINT(4, "calling BBufferConsumer::BufferReceived buffer %ld "
"at perf %Ld and TimeSource()->Now() is %Ld\n",
buffer->Header()->buffer, buffer->Header()->start_time,
TimeSource()->Now());
BufferReceived(buffer);
}
return B_OK;
}
case CONSUMER_PRODUCER_DATA_STATUS:
{
const consumer_producer_data_status_command *command = static_cast<const consumer_producer_data_status_command *>(data);
ProducerDataStatus(command->for_whom, command->status, command->at_performance_time);
return B_OK;
}
case CONSUMER_GET_LATENCY_FOR:
{
const consumer_get_latency_for_request *request = static_cast<const consumer_get_latency_for_request *>(data);
consumer_get_latency_for_reply reply;
rv = GetLatencyFor(request->for_whom, &reply.latency, &reply.timesource);
request->SendReply(rv, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_CONNECTED:
{
const consumer_connected_request *request = static_cast<const consumer_connected_request *>(data);
consumer_connected_reply reply;
reply.input = request->input;
rv = Connected(request->input.source, request->input.destination, request->input.format, &reply.input);
request->SendReply(rv, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_DISCONNECTED:
{
const consumer_disconnected_request *request = static_cast<const consumer_disconnected_request *>(data);
consumer_disconnected_reply reply;
Disconnected(request->source, request->destination);
request->SendReply(B_OK, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_FORMAT_CHANGED:
{
const consumer_format_changed_request *request = static_cast<const consumer_format_changed_request *>(data);
consumer_format_changed_reply reply;
rv = FormatChanged(request->producer, request->consumer, request->change_tag, request->format);
request->SendReply(rv, &reply, sizeof(reply));
// XXX is this RequestCompleted() correct?
node_request_completed_command completedcommand;
completedcommand.info.what = media_request_info::B_FORMAT_CHANGED;
completedcommand.info.change_tag = request->change_tag;
completedcommand.info.status = reply.result;
//completedcommand.info.cookie
completedcommand.info.user_data = 0;
completedcommand.info.source = request->producer;
completedcommand.info.destination = request->consumer;
completedcommand.info.format = request->format;
SendToPort(request->consumer.port, NODE_REQUEST_COMPLETED, &completedcommand, sizeof(completedcommand));
return B_OK;
}
case CONSUMER_SEEK_TAG_REQUESTED:
{
const consumer_seek_tag_requested_request *request = static_cast<const consumer_seek_tag_requested_request *>(data);
consumer_seek_tag_requested_reply reply;
rv = SeekTagRequested(request->destination, request->target_time, request->flags, &reply.seek_tag, &reply.tagged_time, &reply.flags);
request->SendReply(rv, &reply, sizeof(reply));
return B_OK;
}
}
return B_ERROR;
}
vector<SQUID_Connection> sqstat::GetInfo(Options* pOpts) {
sqconn con;
string temp_str;
active_conn = 0;
long long esize;
long etime;
int n=0, delay_pool;
vector<SQUID_Connection>::iterator Conn_it; // pointer to current peer
vector<Uri_Stats>::iterator Stat_it; // pointer to current stat
Uri_Stats newStats;
try {
con.open(pOpts->host, pOpts->port);
}
catch(sqconnException &e) {
std::stringstream error;
error << e.what() << " while connecting to " << pOpts->host << ":" << pOpts->port;
throw sqstatException(error.str(), FAILED_TO_CONNECT);
}
connections.clear();
time_t timenow = 0;
time_t timediff = 0;
try {
string request = "GET cache_object://localhost/active_requests HTTP/1.0\n";
if (!pOpts->pass.empty()) {
string encoded = Base64::Encode("admin:" + pOpts->pass);
request += "Authorization: Basic " + encoded + "\n";
}
con << request;
Uri_Stats oldStats;
while ((con >> temp_str) != 0) {
if (connections.size()==0) {
if (n==0) {
if (temp_str != "HTTP/1.0 200 OK" && temp_str != "HTTP/1.1 200 OK") {
std::stringstream error;
error << "Access to squid statistic denied: " << temp_str;
/*string ip;
try {
ip = get_ip();
}
catch (string) {
ip = "<your_host_ip>";
}*/
/*error << "You must enable access to squid statistic in squid.conf by adding strings like:" << endl << endl;
error << "\tacl adminhost src <admin_host_ip_here>/255.255.255.255" << endl;
error << "\thttp_access allow manager adminhost" << endl;
error << "\thttp_access deny manager";*/
throw sqstatException(error.str(), ACCESS_DENIED);
} else {
n=1;
timenow = time(NULL);
timediff = timenow - lastruntime;
continue;
}
}
}
vector<string> result;
if (temp_str.substr(0,8) == "Server: ") {
result = Utils::SplitString(temp_str, " ");
if (result.size() == 2) {
squid_version = result[1];
} else { FormatChanged(temp_str); }
} else if (temp_str.substr(0,12) == "Connection: ") {
result = Utils::SplitString(temp_str, " ");
if (result.size() == 2) {
newStats.id = result[1];
oldStats = FindUriStatsById(oldConnections, result[1]);
newStats.uri = "";
newStats.username = "";
newStats.size = 0;
newStats.count = 0;
newStats.oldsize = 0;
newStats.etime = 0;
newStats.delay_pool = -1;
} else { FormatChanged(temp_str); }
} else if ((temp_str.substr(0,6) == "peer: ") or (temp_str.substr(0,8) == "remote: ")) {
result = Utils::SplitString(temp_str, " ");
if (result.size() == 2) {
std::pair <string, string> peer = Utils::SplitIPPort(result[1]);
if (!peer.first.empty()) {
Conn_it = std::find_if( connections.begin(), connections.end(), std::bind2nd( std::ptr_fun(ConnByPeer) , peer.first) );
// if it is new peer, create new SQUID_Connection
if (Conn_it == connections.end()) {
SQUID_Connection connection;
connection.peer = peer.first;
#ifdef WITH_RESOLVER
connection.hostname = DoResolve(pOpts, peer.first);
#endif
connections.push_back(connection);
Conn_it = connections.end() - 1;
}
Conn_it->stats.push_back(newStats);
Stat_it = Conn_it->stats.end() - 1;
}
} else { FormatChanged(temp_str); }
} else if (temp_str.substr(0,4) == "uri ") {
result = Utils::SplitString(temp_str, " ");
if (result.size() == 2) {
Stat_it->uri = result[1];
Stat_it->count = 1;
Stat_it->curr_speed = 0;
Stat_it->av_speed = 0;
} else { FormatChanged(temp_str); }
} else if (temp_str.substr(0,11) == "out.offset ") {
result = Utils::SplitString(temp_str, " ");
if (result.size() == 4) {
esize = atoll(result[3].c_str());
Stat_it->size = esize;
Stat_it->oldsize = oldStats.size;
Conn_it->sum_size += esize;
} else { FormatChanged(temp_str); }
} else if (temp_str.substr(0,6) == "start ") {
result = Utils::SplitString(temp_str, " ");
if (result.size() == 5) {
string temp = result[2].erase(0,1);
etime = atoi(temp.c_str());
Stat_it->etime = etime;
if (etime > Conn_it->max_etime)
Conn_it->max_etime = etime;
} else { FormatChanged(temp_str); }
} else if (temp_str.substr(0,11) == "delay_pool ") {
result = Utils::SplitString(temp_str, " ");
if (result.size() == 2) {
string temp = result[1];
delay_pool = atoi(temp.c_str());
Stat_it->delay_pool = delay_pool;
} else { FormatChanged(temp_str); }
} else if (temp_str.substr(0,9) == "username ") {
result = Utils::SplitString(temp_str, " ");
if (result.size() == 1)
result.push_back("-");
if (result.size() == 2) {
string username = result[1];
if (!(username == "-")) {
Utils::ToLower(username);
Stat_it->username = username;
if (!Utils::MemberOf(Conn_it->usernames, username))
Conn_it->usernames.push_back(username);
}
} else { FormatChanged(temp_str); }
}
}
}
catch(sqconnException &e) {
std::stringstream error;
error << e.what();
throw sqstatException(error.str(), UNKNOWN_ERROR);
}
av_speed = 0;
curr_speed = 0;
for (vector<SQUID_Connection>::iterator Conn = connections.begin(); Conn != connections.end(); ++Conn) {
sort(Conn->stats.begin(), Conn->stats.end(), CompareURLs);
active_conn += Conn->stats.size();
for (vector<Uri_Stats>::iterator Stats = Conn->stats.begin(); Stats != Conn->stats.end(); ++Stats) {
long stat_av_speed = 0;
if ((Stats->size != 0) && (Stats->etime != 0))
stat_av_speed = Stats->size/Stats->etime;
Stats->av_speed = stat_av_speed;
Conn->av_speed += stat_av_speed;
av_speed += stat_av_speed;
long stat_curr_speed = 0;
if ((Stats->size != 0) && (Stats->oldsize != 0) && (lastruntime != 0) && (Stats->size > Stats->oldsize)) {
if (timediff < 1) timediff = 1;
stat_curr_speed = (Stats->size - Stats->oldsize) / timediff;
/*if ((stat_curr_speed > 10000000) || (stat_curr_speed < 0)) {
cout << Stats->size << " " << Stats->oldsize << " " << timenow << " " << lastruntime << endl;
throw;
}*/
Stats->curr_speed = stat_curr_speed;
Conn->curr_speed += stat_curr_speed;
curr_speed += stat_curr_speed;
} /*else {
Conn->curr_speed += stat_av_speed;
curr_speed += stat_av_speed;
}*/
}
}
sort(connections.begin(), connections.end(), sqstat::CompareSIZE);
oldConnections = connections;
lastruntime = timenow;
return connections;
}
