Ejemplo n.º 1
0
Archivo: tpod.c Proyecto: grafoo/tpod
static void ev_handler(struct mg_connection *con, int ev, void *ev_data) {
  struct http_message *msg = (struct http_message *)ev_data;

  switch (ev) {
  case MG_EV_HTTP_REQUEST:
    if (mg_vcmp(&msg->uri, "/play") == 0) {
      handle_play(con, msg);
    } else if (mg_vcmp(&msg->uri, "/pause") == 0) {
      if (playback_pause) {
        playback_pause = 0;
      } else {
        playback_pause = 1;
      }
      mg_printf(con, "HTTP/1.1 200 OK\r\n\r\n%s");
    } else if (mg_vcmp(&msg->uri, "/stop") == 0) {
      handle_stop(con, msg);
    } else if (mg_vcmp(&msg->uri, "/init") == 0) {
      if (tpod_mg_str_cmp(&msg->method, &msg_http_method_get)) {
        /* char query_string[msg->query_string.len + 1]; */
        /* strncpy(query_string, msg->query_string.p, msg->query_string.len); */

        char *jsnstr_podcasts_obj = load_episodes();

        mg_printf(con, "HTTP/1.1 200 OK\r\nContent-Type: "
                       "application/json\r\nContent-Length: %d\r\n\r\n%s",
                  (int)strlen(jsnstr_podcasts_obj), jsnstr_podcasts_obj);
      }
    } else {
      mg_serve_http(con, msg, s_http_server_opts);
    }
    break;
  default:
    break;
  }
}
/**
 * Handle a request and send a response
 *
 * @param cls unused
 * @param other the sender
 * @param message the message
 * @return GNUNET_OK to keep connection, GNUNET_SYSERR on error
 */
static int
core_receive_handler (void *cls,
		      const struct GNUNET_PeerIdentity *other,
		      const struct GNUNET_MessageHeader *message)
{
	if (ntohs (message->size) < sizeof (struct GNUNET_MessageHeader))
	{
			GNUNET_break (0);
			return GNUNET_SYSERR;
	}

	switch (ntohs (message->type)) {
		case GNUNET_MESSAGE_TYPE_EXPERIMENTATION_REQUEST:
			handle_request (other, message);
			break;
		case GNUNET_MESSAGE_TYPE_EXPERIMENTATION_RESPONSE:
			handle_response (other, message);
			break;
		case GNUNET_MESSAGE_TYPE_EXPERIMENTATION_START:
			handle_start (other, message);
			break;
		case GNUNET_MESSAGE_TYPE_EXPERIMENTATION_START_ACK:
			handle_start_ack (other, message);
			break;
		case GNUNET_MESSAGE_TYPE_EXPERIMENTATION_STOP:
			handle_stop (other, message);
			break;
		default:
			break;
	}

	return GNUNET_OK;
}
Ejemplo n.º 3
0
Archivo: core.c Proyecto: catoc/Comojs
int timer_stop (evHandle *handle) {
    if (!handle || !_is_active(handle)) return 0;
    evTimer *timer = handle->ev;
    heap_remove((struct heap*) &handle->loop->timer_heap,
              (struct heap_node*) &timer->heap_node,
              timer_less_than);
    
    handle_stop(handle);
    return 0;
}
Ejemplo n.º 4
0
  //--------------------------------------------------------------------------------
  void Server::stop()
  {
    LogStream log(__PRETTY_FUNCTION__);
    handle_stop();

    log << manip::info_normal
        << "--------------------------------------------------------------------------------"  << '\n'
        << "Stopping Process : " << Config::instance()->getAppId()                             << '\n'
        << "Instance         : " << Config::instance()->getAppInstance()                       << '\n'
        << "Server address   : " << Config::instance()->get<std::string>("kcc-server.address") << '\n'
        << "Server port      : " << Config::instance()->get<std::string>("kcc-server.port")    << '\n'
        << "--------------------------------------------------------------------------------"  << manip::endl;
  }
Ejemplo n.º 5
0
Archivo: core.c Proyecto: Comojs/comojs
void handle_close (evHandle *h){
	if ((h->flags & HANDLE_CLOSING) != 0) return;
	if (h->type == EV_IO){
		io_close(h);
	} else if (h->type == EV_TIMER){
		timer_close(h);
	} else {
		handle_stop(h);
		h->flags |= HANDLE_CLOSING;
		QUEUE_REMOVE(&h->queue);
		QUEUE_INSERT_TAIL(&h->loop->closing_queue,
						  &h->queue);

		//closing un initaited handle
		//assert(0 && "CLOSING UNKNOWN HANDLE\n");
	}
}
Ejemplo n.º 6
0
/// Ask the server to stop using asynchronous command
void server_base::stop() {
	if (is_running) {
		// Post a call to the stop function so that server_base::stop() is safe to call from any thread.
		io_service_.post(boost::bind(&server_base::handle_stop, this));
	} else {
		// if io_service is not running then the post call will not be performed
		handle_stop();
	}

	// Wait for acceptor and connections to stop
	int timeout = 15; // force stop after 15 seconds
	time_t start = mytime(NULL);
	while(true) {
		if (!is_running && is_stop_complete) {
			break;
		}
		if ((mytime(NULL) - start) > timeout) {
			// timeout occurred
			break;
		}
		sleep_milliseconds(500);
	}
}
Ejemplo n.º 7
0
int main(int argc, char *argv[])
{
  std::string app_name(argv[0]);
  unsigned short port_number(via::comms::tcp_adaptor::DEFAULT_HTTP_PORT);

  // Get a port number from the user (the default is 80)
  if (argc > 2)
  {
    std::cerr << "Usage: " << app_name << " [port number]\n"
              << "E.g. "   << app_name << " " << port_number
              << std::endl;
    return 1;
  }
  else if (argc == 2)
  {
    std::string port(argv[1]);
    port_number = atoi(port.c_str());
  }

  std::cout << app_name << ": " << port_number << std::endl;

  try
  {
    // create an io_service for the server
    ASIO::io_service io_service;

    // create an http_server and connect the request handler
    http_server_type http_server(io_service);
    http_server.request_received_event(request_handler);

    // connect the optional handler callback functions
    http_server.chunk_received_event(chunk_handler);
    http_server.request_expect_continue_event(expect_continue_handler);
    http_server.invalid_request_event(invalid_request_handler);
    http_server.socket_connected_event(connected_handler);
    http_server.socket_disconnected_event(disconnected_handler);
    http_server.message_sent_event(message_sent_handler);

    // set the connection timeout (10 seconds)
    http_server.set_timeout(10000);

    // set the connection buffer sizes
    http_server.set_rx_buffer_size(16384);
    http_server.tcp_server()->set_receive_buffer_size(16384);
    http_server.tcp_server()->set_send_buffer_size(16384);

    // start accepting http connections on the port
    ASIO_ERROR_CODE error(http_server.accept_connections(port_number));
    if (error)
    {
      std::cerr << "Error: "  << error.message() << std::endl;
      return 1;
    }

    // The signal set is used to register termination notifications
    ASIO::signal_set signals_(io_service);
    signals_.add(SIGINT);
    signals_.add(SIGTERM);
#if defined(SIGQUIT)
    signals_.add(SIGQUIT);
#endif // #if defined(SIGQUIT)

    // register the handle_stop callback
    signals_.async_wait([&http_server]
      (ASIO_ERROR_CODE const& error, int signal_number)
    { handle_stop(error, signal_number, http_server); });

    // run the io_service to start communications
    io_service.run();

    std::cout << "io_service.run complete, shutdown successful" << std::endl;
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception:"  << e.what() << std::endl;
  }

  return 0;
}
Ejemplo n.º 8
0
facade::~facade()
{
#if 0
	handle_stop();
#endif
}
Ejemplo n.º 9
0
facade_extension::~facade_extension()
{
	handle_stop();
}
Ejemplo n.º 10
0
client<NetSpeedThreads, TimerSpeedThreads>::~client()
{
	handle_stop();
}
Ejemplo n.º 11
0
int main(int argc, char *argv[])
{
  std::string app_name(argv[0]);
  unsigned short port_number(via::comms::tcp_adaptor::DEFAULT_HTTP_PORT);

  // Get a port number from the user (the default is 80)
  if (argc > 2)
  {
    std::cerr << "Usage: " << app_name << " [port number]\n"
              << "E.g. "   << app_name << " " << port_number
              << std::endl;
    return 1;
  }
  else if (argc == 2)
  {
    std::string port(argv[1]);
    port_number = atoi(port.c_str());
  }

  std::cout << app_name << ": " << port_number << std::endl;

  try
  {
    // create an io_service for the server
    boost::asio::io_service io_service;

    // create an http_server and connect the request handler
    http_server_type http_server(io_service);
    http_server.request_received_event(request_handler);

    // connect the handler callback functions
    http_server.chunk_received_event(chunk_handler);
    http_server.request_expect_continue_event(expect_continue_handler);
    http_server.invalid_request_event(invalid_request_handler);
    http_server.socket_connected_event(connected_handler);
    http_server.socket_disconnected_event(disconnected_handler);
    http_server.message_sent_event(message_sent_handler);

    // start accepting http connections on the given port
    boost::system::error_code error(http_server.accept_connections(port_number));
    if (error)
    {
      std::cerr << "Error: "  << error.message() << std::endl;
      return 1;
    }

    // The signal set is used to register for termination notifications
    boost::asio::signal_set signals_(io_service);
    signals_.add(SIGINT);
    signals_.add(SIGTERM);
#if defined(SIGQUIT)
    signals_.add(SIGQUIT);
#endif // #if defined(SIGQUIT)

    // register the handle_stop callback
    signals_.async_wait([&http_server]
      (boost::system::error_code const& error, int signal_number)
    { handle_stop(error, signal_number, http_server); });

    // Determine the number of concurrent threads supported
    size_t no_of_threads(std::thread::hardware_concurrency());
    std::cout << "No of threads: " << no_of_threads << std::endl;

    if (no_of_threads > 0)
    {
      // Create a thread pool for the threads and run the asio io_service
      // in each of the threads.
      std::vector<std::shared_ptr<std::thread> > threads;
      for (std::size_t i = 0; i < no_of_threads; ++i)
      {
        std::shared_ptr<std::thread> thread(std::make_shared<std::thread>
                             ([&io_service](){ io_service.run(); }));
        threads.push_back(thread);
      }

      // Wait for all threads in the pool to exit.
      for (std::size_t i(0); i < threads.size(); ++i)
        threads[i]->join();
    }
    else
      io_service.run();

    std::cout << "io_service.run, all work has finished" << std::endl;
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception:"  << e.what() << std::endl;
  }

  return 0;
}