Пример #1
0
void my::GateServer::handle_accept(ConnectionPtr conn, boost::system::error_code err)
{
	if (err)
	{
		LogE << err.message() << LogEnd;
		conn->getSocket().close();
		ConnectionPtr nextConn = boost::shared_ptr<TcpConnection>(new TcpConnection(core.getService(), m_GateHandler, shared_from_this()));
		m_pAcceptor->async_accept(nextConn->getSocket(), boost::bind(&GateServer::handle_accept, this, nextConn, boost::asio::placeholders::error));
	}
	else
	{
		//new incomming player!!!
		LogD << conn->getSocket().remote_endpoint().address() << " " << conn->getSocket().remote_endpoint().port() << LogEnd;

		boost::recursive_mutex::scoped_lock lock(mtx);
		conn->setNetId(m_nNetIdHolder);
		ip::tcp::no_delay option(true);
		conn->getSocket().set_option(option);
		m_ConnMap.insert(std::make_pair<int, ConnectionPtr>(m_nNetIdHolder, conn));		
		conn->start();
		m_nNetIdHolder = (m_nNetIdHolder + 1) % MAX_NET_ID;
		m_nConnCount++;
			
		ConnectionPtr nextConn = boost::shared_ptr<TcpConnection>(new TcpConnection(core.getService(), m_GateHandler, shared_from_this()));
		m_pAcceptor->async_accept(nextConn->getSocket(), boost::bind(&GateServer::handle_accept, this, nextConn, boost::asio::placeholders::error));
	}
}
CrowdDetectorFilterImpl::CrowdDetectorFilterImpl (
  const std::vector<std::shared_ptr<RegionOfInterest>> &rois,
  std::shared_ptr< MediaObjectImpl > parent) :
  FilterImpl (parent)
{
  GstBus *bus;
  std::shared_ptr<MediaPipelineImpl> pipe;
  GstStructure *roisStructure;

  pipe = std::dynamic_pointer_cast<MediaPipelineImpl> (getMediaPipeline() );

  g_object_set (element, "filter-factory", "crowddetector", NULL);

  bus = gst_pipeline_get_bus (GST_PIPELINE (pipe->getPipeline() ) );

  g_object_get (G_OBJECT (element), "filter", &crowdDetector, NULL);

  if (crowdDetector == NULL) {
    g_object_unref (bus);
    throw KurentoException (MEDIA_OBJECT_NOT_AVAILABLE,
                            "Media Object not available");
  }

  roisStructure = gst_structure_new_empty  ("Rois");

  for (auto roi : rois) {
    GstStructure *roiStructureAux = get_structure_from_roi (roi);

    gst_structure_set (roisStructure,
                       roi->getId().c_str(), GST_TYPE_STRUCTURE,
                       roiStructureAux,
                       NULL);

    gst_structure_free (roiStructureAux);
  }

  g_object_set (G_OBJECT (crowdDetector), ROIS_PARAM, roisStructure, NULL);
  gst_structure_free (roisStructure);

  busMessageLambda = [&] (GstMessage * message) {
    const GstStructure *st;
    gchar *roiID;
    const gchar *type;
    std::string roiIDStr, typeStr;

    if (GST_MESSAGE_SRC (message) != GST_OBJECT (crowdDetector) ||
        GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT) {
      return;
    }

    st = gst_message_get_structure (message);
    type = gst_structure_get_name (st);

    if (!gst_structure_get (st, "roi", G_TYPE_STRING , &roiID, NULL) ) {
      GST_WARNING ("The message does not contain the roi ID");
      return;
    }

    roiIDStr = roiID;
    typeStr = type;

    g_free (roiID);

    if (typeStr == "fluidity-event") {

      double fluidity_percentage;
      int fluidity_level;

      if (! (gst_structure_get (st, "fluidity_percentage", G_TYPE_DOUBLE,
                                &fluidity_percentage, NULL) ) ) {
        GST_WARNING ("The message does not contain the fluidity percentage");
        return;
      }

      if (! (gst_structure_get (st, "fluidity_level", G_TYPE_INT,
                                &fluidity_level, NULL) ) ) {
        GST_WARNING ("The message does not contain the fluidity level");
        return;
      }

      try {
        CrowdDetectorFluidity event (fluidity_percentage, fluidity_level, roiIDStr,
                                     shared_from_this(),
                                     CrowdDetectorFluidity::getName() );
        signalCrowdDetectorFluidity (event);
      } catch (std::bad_weak_ptr &e) {
      }
    } else if (typeStr == "occupancy-event") {

      double occupancy_percentage;
      int occupancy_level;

      if (! (gst_structure_get (st, "occupancy_percentage", G_TYPE_DOUBLE,
                                &occupancy_percentage, NULL) ) ) {
        GST_WARNING ("The message does not contain the occupancy percentage");
        return;
      }

      if (! (gst_structure_get (st, "occupancy_level", G_TYPE_INT,
                                &occupancy_level, NULL) ) ) {
        GST_WARNING ("The message does not contain the occupancy level");
        return;
      }

      try {
        CrowdDetectorOccupancy event (occupancy_level, occupancy_percentage,
                                      roiIDStr, shared_from_this(),
                                      CrowdDetectorOccupancy::getName() );
        signalCrowdDetectorOccupancy (event);
      } catch (std::bad_weak_ptr &e) {
      }
    } else if (typeStr == "direction-event") {

      double direction_angle;

      if (! (gst_structure_get (st, "direction_angle", G_TYPE_DOUBLE,
                                &direction_angle, NULL) ) ) {
        GST_WARNING ("The message does not contain the direction angle");
        return;
      }

      try {
        CrowdDetectorDirection event (direction_angle, roiIDStr, shared_from_this(),
                                      CrowdDetectorDirection::getName() );
        signalCrowdDetectorDirection (event);
      } catch (std::bad_weak_ptr &e) {
      }
    } else {
      GST_WARNING ("The message does not have the correct name");
    }
  };

  bus_handler_id = g_signal_connect (bus, "message",
                                     G_CALLBACK (bus_message_adaptor),
                                     &busMessageLambda);
  g_object_unref (bus);

  // There is no need to reference crowddetector because its life cycle is the same as the filter life cycle
  g_object_unref (crowdDetector);
}
Пример #3
0
void Node::forwardProperty(int ourProperty, std::shared_ptr<Node> toNode, int toProperty) {
	forwarded_properties[ourProperty] = std::make_tuple(toNode, toProperty);
	toNode->addPropertyBackref(toProperty, std::static_pointer_cast<Node>(shared_from_this()), ourProperty);
	simulation->invalidatePlan();
}
Пример #4
0
std::shared_ptr<base::IBlock> BlockFS::block() const {
    return std::const_pointer_cast<BlockFS>(shared_from_this());
}
Пример #5
0
neb::fnd::app::Base * const		THIS::get_fnd_app()
{
	auto a = std::dynamic_pointer_cast<neb::fnd::app::Base>(shared_from_this());

	return a.get();
}
Пример #6
0
viewer::PluginPtr ModelLoaderPlugin::init(ViewerPtr viewer)
{
   const std::string plugin_tkn("model_loader_plugin");
   const std::string units_to_meters_tkn("units_to_meters");
   const std::string position_tkn("position");
   const std::string rotation_tkn("rotation");
   const std::string models_tkn("models");
   const std::string path_tkn("path");
   const std::string grabbing_tkn("enable_grabbing");
   const std::string core_type_tkn("core_type");

   const unsigned int req_cfg_version(1);

   jccl::ConfigElementPtr elt =
      viewer->getConfiguration().getConfigElement(plugin_tkn);

   if ( !elt )
   {
      std::stringstream ex_msg;
      ex_msg << "Model loader plug-in could not find its configuration.  "
             << "Looking for type: " << plugin_tkn;
      throw PluginException(ex_msg.str(), VRKIT_LOCATION);
   }

   // -- Read configuration -- //
   vprASSERT(elt->getID() == plugin_tkn);

   // Check for correct version of plugin configuration
   if ( elt->getVersion() < req_cfg_version )
   {
      std::stringstream msg;
      msg << "ModelLoaderPlugin: Configuration failed. Required cfg version: "
          << req_cfg_version << " found:" << elt->getVersion();
      throw PluginException(msg.str(), VRKIT_LOCATION);
   }

   // Get the scaling factor
   const float to_meters = elt->getProperty<float>(units_to_meters_tkn);

   // Get the paths to all the models, load them, and add them to the scene
   ScenePtr scene = viewer->getSceneObj();
   OSG::TransformNodePtr scene_xform_root = scene->getTransformRoot();

#if OSG_MAJOR_VERSION < 2
   OSG::CPEditor sxre(scene_xform_root.node(), OSG::Node::ChildrenFieldMask);
#endif

   const unsigned int num_models(elt->getNum(models_tkn));
   for ( unsigned int i = 0; i < num_models; ++i )
   {
      jccl::ConfigElementPtr model_elt =
         elt->getProperty<jccl::ConfigElementPtr>(models_tkn, i);
      vprASSERT(model_elt.get() != NULL);
      const std::string model_path =
         model_elt->getProperty<std::string>(path_tkn);
      OSG::NodeRefPtr model_node(
#if OSG_MAJOR_VERSION < 2
         OSG::SceneFileHandler::the().read(model_path.c_str())
#else
         OSG::SceneFileHandler::the()->read(model_path.c_str())
#endif
      );

      if ( model_node != OSG::NullFC )
      {
         // Set up the model switch transform
         const float xt =
            model_elt->getProperty<float>(position_tkn, 0) * to_meters;
         const float yt =
            model_elt->getProperty<float>(position_tkn, 1) * to_meters;
         const float zt =
            model_elt->getProperty<float>(position_tkn, 2) * to_meters;

         const float xr = model_elt->getProperty<float>(rotation_tkn, 0);
         const float yr = model_elt->getProperty<float>(rotation_tkn, 1);
         const float zr = model_elt->getProperty<float>(rotation_tkn, 2);

         gmtl::Coord3fXYZ coord;
         coord.pos().set(xt,yt,zt);
         coord.rot().set(gmtl::Math::deg2Rad(xr), gmtl::Math::deg2Rad(yr),
                         gmtl::Math::deg2Rad(zr));

         // Set at T*R
         OSG::Matrix xform_mat_osg;
         gmtl::set(xform_mat_osg, gmtl::make<gmtl::Matrix44f>(coord));

         OSG::NodeRefPtr child_root;

         // If this model is supposed to be grabbable, we create a vrkit
         // dynamic scene object for it. As a result, we can be assured
         // that the root node will have a core of type OSG::Transform.
         if ( model_elt->getProperty<bool>(grabbing_tkn) )
         {
            std::vector<OSG::FieldContainerType*> core_types;
            const unsigned int num_types = model_elt->getNum(core_type_tkn);
            for ( unsigned int t = 0; t < num_types; ++t )
            {
               const std::string type_name = 
                  model_elt->getProperty<std::string>(core_type_tkn, i);
               OSG::FieldContainerType* fct =
                  OSG::FieldContainerFactory::the()->findType(
                     type_name.c_str()
                  );

               if ( NULL != fct )
               {
                  core_types.push_back(fct);
               }
               else
               {
                  VRKIT_STATUS << "Skipping unknown type '" << type_name
                               << "'" << std::endl;
               }
            }

            DynamicSceneObjectPtr scene_obj;

            if ( ! core_types.empty() )
            {
               util::CoreTypePredicate pred(core_types);
               scene_obj = DynamicSceneObject::create()->init(model_node,
                                                              pred, true);
            }
            else
            {
               scene_obj =
                  DynamicSceneObjectTransform::create()->init(model_node);
            }

            // scene_obj's root will be added as a child of
            // scene_xform_root.
            child_root = scene_obj->getRoot();
            scene_obj->moveTo(xform_mat_osg);
            viewer->addObject(scene_obj);
         }
         // If this model is not supposed to be grabbable, we examine the
         // core of the root node.
         else
         {
            OSG::NodeCorePtr root_core = model_node->getCore();
            OSG::TransformPtr xform_core =
#if OSG_MAJOR_VERSION < 2
               OSG::TransformPtr::dcast(root_core);
#else
               OSG::cast_dynamic<OSG::TransformPtr>(root_core);
#endif

            // If model_node's core is of type OSG::Transform, then we set
            // set the matrix on that core to be xform_mat_osg.
            if ( OSG::NullFC != xform_core )
            {
#if OSG_MAJOR_VERSION < 2
               OSG::CPEditor xce(xform_core, OSG::Transform::MatrixFieldMask);
#endif
               xform_core->setMatrix(xform_mat_osg);

               // model_node will be added as a child of scene_xform_root.
               child_root = model_node;
            }
            // If model_node's core is not of type OSG::Transform, then we
            // need to make a new node with an OSG::Transform core and make
            // it the parent of model_node.
            else
            {
               OSG::TransformNodePtr xform_node(OSG::Transform::create());

#if OSG_MAJOR_VERSION < 2
               OSG::CPEditor xnce(xform_node.core(),
                                  OSG::Transform::MatrixFieldMask);
#endif
               xform_node->setMatrix(xform_mat_osg);

#if OSG_MAJOR_VERSION < 2
               OSG::CPEditor xne(xform_node.node(),
                                 OSG::Node::ChildrenFieldMask);
#endif
               xform_node.node()->addChild(model_node);

               // xform_node will be added as a child of scene_xform_root.
               child_root = xform_node.node();
            }
         }

         vprASSERT(child_root != OSG::NullFC);

         // The OSG::{begin,end}EditCP() calls for scene_xform_root wrap
         // the for loop that we are in.
         scene_xform_root.node()->addChild(child_root);
      }
   }

   return shared_from_this();
}
bool Subscription::negotiateConnection(const std::string& xmlrpc_uri)
{


  XmlRpcValue tcpros_array, protos_array, params;
  XmlRpcValue udpros_array;
  ros::TransportUDPPtr udp_transport;
  int protos = 0;
  ros::V_string transports = transport_hints_.getTransports();
  if (transports.empty())
  {
    transport_hints_.reliable();
    transports = transport_hints_.getTransports();
  }
  for (ros::V_string::const_iterator it = transports.begin();
       it != transports.end();
       ++it)
  {
    if (*it == "UDP")
    {
      int max_datagram_size = transport_hints_.getMaxDatagramSize();
      udp_transport = ros::TransportUDPPtr(new ros::TransportUDP(&ros::PollManager::instance()->getPollSet()));
      if (!max_datagram_size)
        max_datagram_size = udp_transport->getMaxDatagramSize();
      udp_transport->createIncoming(0, false);
      udpros_array[0] = "UDPROS";
      M_string m;
      m["topic"] = getName();
      m["md5sum"] = md5sum();
      m["callerid"] = ros::this_node::getName();
      m["type"] = datatype();
      boost::shared_array<uint8_t> buffer;
      uint32_t len;
      ros::Header::write(m, buffer, len);
      XmlRpcValue v(buffer.get(), len);
      udpros_array[1] = v;
      udpros_array[2] = ros::network::getHost();
      udpros_array[3] = udp_transport->getServerPort();
      udpros_array[4] = max_datagram_size;

      protos_array[protos++] = udpros_array;
    }
    else if (*it == "TCP")
    {
      tcpros_array[0] = std::string("TCPROS");
      protos_array[protos++] = tcpros_array;
    }
    else
    {
      ROS_WARN("Unsupported transport type hinted: %s, skipping", it->c_str());
    }
  }
  params[0] = ros::this_node::getName();
  params[1] = name_;
  params[2] = protos_array;
  std::string peer_host;
  uint32_t peer_port;
  if (!ros::network::splitURI(xmlrpc_uri, peer_host, peer_port))
  {
    ROS_ERROR("Bad xml-rpc URI: [%s]", xmlrpc_uri.c_str());
    return false;
  }

  XmlRpcClient* c = new XmlRpcClient(peer_host.c_str(),
                                                     peer_port, "/");
 // if (!c.execute("requestTopic", params, result) || !g_node->validateXmlrpcResponse("requestTopic", result, proto))

  // Initiate the negotiation.  We'll come back and check on it later.
  if (!c->executeNonBlock("requestTopic", params))
  {
    ROSCPP_LOG_DEBUG("Failed to contact publisher [%s:%d] for topic [%s]",
              peer_host.c_str(), peer_port, name_.c_str());
    delete c;
    if (udp_transport)
    {
      udp_transport->close();
    }

    return false;
  }

  ROSCPP_LOG_DEBUG("Began asynchronous xmlrpc connection to [%s:%d]", peer_host.c_str(), peer_port);

  // The PendingConnectionPtr takes ownership of c, and will delete it on
  // destruction.
  PendingConnectionPtr conn(new PendingConnection(c, udp_transport, shared_from_this(), xmlrpc_uri));

//ROS_INFO("add connection to xmlrpcmanager");

  XMLRPCManager::instance()->addASyncConnection(conn);
  // Put this connection on the list that we'll look at later.
  {
    boost::mutex::scoped_lock pending_connections_lock(pending_connections_mutex_);
    pending_connections_.insert(conn);
  }

  return true;
}
Пример #8
0
CameraPtr Camera::init()
{
   // Create a transform to contain the location and orientation of the camera.
   mTransform = OSG::Transform::create();

   OSG::NodePtr beacon = OSG::Node::create();
#if OSG_MAJOR_VERSION < 2
   OSG::CPEditor be(beacon, OSG::Node::CoreFieldMask);
#endif
   beacon->setCore(mTransform);

   mLeftTexture = tex_chunk_t::create();
#if OSG_MAJOR_VERSION < 2
   OSG::CPEditor lte(mLeftTexture);
   mLeftTexture->setEnvMode(GL_MODULATE);
#else
   mLeftTexEnv = OSG::TextureEnvChunk::create();
   mLeftTexEnv->setEnvMode(GL_MODULATE);
#endif

   mRightTexture = tex_chunk_t::create();
#if OSG_MAJOR_VERSION < 2
   OSG::CPEditor rte(mRightTexture);
   mRightTexture->setEnvMode(GL_MODULATE);
#else
   mRightTexEnv = OSG::TextureEnvChunk::create();
   mRightTexEnv->setEnvMode(GL_MODULATE);
#endif

   mCurrentTexture = mLeftTexture;
#if OSG_MAJOR_VERSION >= 2
   mCurrentTexEnv = mLeftTexEnv;
#endif

   // setup camera
   mCamera = OSG::PerspectiveCamera::create();
#if OSG_MAJOR_VERSION < 2
   OSG::CPEditor ce(mCamera);
#endif
   mCamera->setFov(
#if OSG_MAJOR_VERSION < 2
      OSG::osgdegree2rad(60.0)
#else
      OSG::osgDegree2Rad(60.0)
#endif
   );
   mCamera->setNear(0.01);
   mCamera->setFar(10000);
   mCamera->setBeacon(beacon);

   mLeftImage = OSG::Image::create();
   mRightImage = OSG::Image::create();

   OSG::ImagePtr img;

   // Set up FBO textures.
   img = mLeftImage;
   mLeftTexture->setMinFilter(GL_LINEAR);
   mLeftTexture->setMagFilter(GL_LINEAR);
   mLeftTexture->setTarget(GL_TEXTURE_2D);
   mLeftTexture->setInternalFormat(GL_RGBA8);
   mLeftTexture->setImage(img);

   img = mRightImage;
   mRightTexture->setMinFilter(GL_LINEAR);
   mRightTexture->setMagFilter(GL_LINEAR);
   mRightTexture->setTarget(GL_TEXTURE_2D);
   mRightTexture->setInternalFormat(GL_RGBA8);
   mRightTexture->setImage(img);

   mCurrentImage = mLeftImage;

   return shared_from_this();
}
Пример #9
0
void SuggestionsSidebarBlock::QueryProvider(SuggestionsBackend& backend, const CatalogItemPtr& item, uint64_t queryId)
{
    m_pendingQueries++;

    // we need something to talk to GUI thread through that is guaranteed
    // to exist, and the app object is a good choice:
    auto backendPtr = &backend;
    std::weak_ptr<SuggestionsSidebarBlock> weakSelf = std::dynamic_pointer_cast<SuggestionsSidebarBlock>(shared_from_this());

    m_provider->SuggestTranslation
    (
        backend,
        m_parent->GetCurrentSourceLanguage(),
        m_parent->GetCurrentLanguage(),
        item->GetString().ToStdWstring(),

        // when receiving data
        [=](const SuggestionsList& hits){
            call_on_main_thread([weakSelf,queryId,hits]{
                auto self = weakSelf.lock();
                // maybe this call is already out of date:
                if (!self || self->m_latestQueryId != queryId)
                    return;
                self->UpdateSuggestions(hits);
                if (--self->m_pendingQueries == 0)
                    self->OnQueriesFinished();
            });
        },

        // on error:
        [=](std::exception_ptr e){
            call_on_main_thread([weakSelf,queryId,backendPtr,e]{
                auto self = weakSelf.lock();
                // maybe this call is already out of date:
                if (!self || self->m_latestQueryId != queryId)
                    return;
                self->ReportError(backendPtr, e);
                if (--self->m_pendingQueries == 0)
                    self->OnQueriesFinished();
            });
        }
    );
}
void PlayListFolder::AddPlayList(boost::shared_ptr<PlayListElement> playList) {
    playList->SetParent(shared_from_this());
    playlists_.push_back(playList);
}
Пример #11
0
IDatabaseSPtr RedisServer::createDatabase(IDataBaseInfoSPtr info) {
  return IDatabaseSPtr(new RedisDatabase(shared_from_this(), info));
}
Пример #12
0
StructuredScript::Interfaces::Node::Ptr StructuredScript::Nodes::EchoNode::ptr(){
	return shared_from_this();
}
Пример #13
0
void my::GateServer::connectToAccountSvr(std::string ipaddr, int port)
{
	std::string portStr = boost::lexical_cast<std::string, int>(port);
	m_pAccountConn = boost::shared_ptr<TcpConnection>(new TcpConnection(core.getService(), m_GateHandler, shared_from_this()));
	m_pAccountConn->setNetId(my::server_id::ACCOUNT_SVR);
	connect(ipaddr, portStr, m_pAccountConn);
}
Пример #14
0
void my::GateServer::init()
{
	boost::shared_ptr<TcpServer> serverPtr(this); //make sure that shared_from_this() can run perfectly ok!
	Json::Value gateConf = util::fileSystem::loadJsonFileEval(jsonconf::server_config);
	if (gateConf == Json::nullValue)
	{
		LogW << "Error init GateServer, null gateConf" << LogEnd;
		return;
	}
	//初始化httpSvr
	{
		m_HttpServerPtr = HttpServerPtr(new http::HttpServer());
		m_HttpServerPtr->init(gateConf);
		m_HttpServerPtr->run();
	}
	m_GateConf = gateConf;
	int	port = gateConf["gateSvrPort"].asInt();
	std::string gameSvrIp = gateConf["gameSvrIp"].asString();
	int gameSvrPort = gateConf["gameSvrPort"].asInt();
	std::string accountSvrIp = gateConf["accountSvrIp"].asString();
	int accountSvrPort = gateConf["accountSvrPort"].asInt();

	m_nConnCount = 0;
	m_nNetIdHolder = 0;
	m_pEndpoint = EndpointPtr(new boost::asio::ip::tcp::endpoint(ip::tcp::v4(), port));
	m_pAcceptor = AcceptorPtr(new boost::asio::ip::tcp::acceptor(core.getService(), *m_pEndpoint));

	m_GateHandler = boost::shared_ptr<GateHandler>(new GateHandler());
	ConnectionPtr nextConn = boost::shared_ptr<TcpConnection>(new TcpConnection(core.getService(), m_GateHandler, shared_from_this()));
	m_pAcceptor->async_accept(nextConn->getSocket(), boost::bind(&GateServer::handle_accept, this, nextConn, boost::asio::placeholders::error));

	connectToGameSvr(gameSvrIp, gameSvrPort);
	connectToAccountSvr(accountSvrIp, accountSvrPort);

	LogD << "Init Gate Server Ok!!!" << LogEnd;

	update();
}
Пример #15
0
void CShips::Retreat(const CPoint& ptRetreatSector, COMBAT_TACTIC::Typ const* NewCombatTactic)
{
	NotifySector temp(shared_from_this());
	CShip::Retreat(ptRetreatSector, NewCombatTactic);
}
Пример #16
0
void Player::collidedBy(std::shared_ptr<Actor> a) {
    a->collideWith(std::static_pointer_cast<Player>(shared_from_this()));
}
Пример #17
0
sf::Vector2f CBaseControl::ConvertPointToControl(const sf::Vector2f & pt, const CBaseControlConstPtr & control) const
{
	return control->ConvertPointFromControl(pt, shared_from_this());
}
Пример #18
0
void UIWidget::RequestFocus(){
  auto p = parent.lock();
  if(!p) return;
  p->OnChildFocusRequested(shared_from_this());
}
Пример #19
0
void Connection::parsePacket(const boost::system::error_code& error)
{
	m_connectionLock.lock();
	m_readTimer.cancel();

	if (error) {
		handleReadError(error);
	}

	if (m_connectionState != CONNECTION_STATE_OPEN || m_readError) {
		closeConnection();
		m_connectionLock.unlock();
		return;
	}

	uint32_t timePassed = std::max<uint32_t>(1, (time(nullptr) - m_timeConnected) + 1);
	if ((++m_packetsSent / timePassed) > (uint32_t)g_config.getNumber(ConfigManager::MAX_PACKETS_PER_SECOND)) {
		std::cout << convertIPToString(getIP()) << " disconnected for exceeding packet per second limit." << std::endl;
		closeConnection();
		m_connectionLock.unlock();
		return;
	}

	if (timePassed > 2) {
		m_timeConnected = time(nullptr);
		m_packetsSent = 0;
	}

	//Check packet checksum
	uint32_t checksum;
	int32_t len = m_msg.getMessageLength() - m_msg.getReadPos() - 4;
	if (len > 0) {
		checksum = adlerChecksum(m_msg.getBuffer() + m_msg.getReadPos() + 4, len);
	} else {
		checksum = 0;
	}

	uint32_t recvChecksum = m_msg.get<uint32_t>();
	if (recvChecksum != checksum) {
		// it might not have been the checksum, step back
		m_msg.SkipBytes(-4);
	}

	if (!m_receivedFirst) {
		// First message received
		m_receivedFirst = true;

		if (!m_protocol) {
			// Game protocol has already been created at this point
			m_protocol = m_service_port->make_protocol(recvChecksum == checksum, m_msg);
			if (!m_protocol) {
				closeConnection();
				m_connectionLock.unlock();
				return;
			}

			m_protocol->setConnection(shared_from_this());
		} else {
			m_msg.GetByte();    // Skip protocol ID
		}

		m_protocol->onRecvFirstMessage(m_msg);
	} else {
		m_protocol->onRecvMessage(m_msg);    // Send the packet to the current protocol
	}

	try {
		m_readTimer.expires_from_now(boost::posix_time::seconds(Connection::read_timeout));
		m_readTimer.async_wait( std::bind(&Connection::handleReadTimeout, std::weak_ptr<Connection>(shared_from_this()),
		                                    std::placeholders::_1));

		// Wait to the next packet
		boost::asio::async_read(getHandle(),
		                        boost::asio::buffer(m_msg.getBuffer(), NetworkMessage::header_length),
		                        std::bind(&Connection::parseHeader, shared_from_this(), std::placeholders::_1));
	} catch (boost::system::system_error& e) {
		if (m_logError) {
			std::cout << "[Network error - Connection::parsePacket] " << e.what() << std::endl;
			m_logError = false;
		}

		closeConnection();
	}

	m_connectionLock.unlock();
}
Пример #20
0
bool UIWidget::IsFocused() const{
  auto p = parent.lock();
  if(!p) return IsRoot(); // Root widgets are always focused, but parentless widgets never.
  return p->OnChildFocusTested(shared_from_this());
}
void Subscription::pendingConnectionDone(const PendingConnectionPtr& conn, XmlRpcValue& result)
{
  boost::mutex::scoped_lock lock(shutdown_mutex_);
  if (shutting_down_ || dropped_)
  {
    return;
  }

  {
    boost::mutex::scoped_lock pending_connections_lock(pending_connections_mutex_);
    pending_connections_.erase(conn);
  }

  ros::TransportUDPPtr udp_transport;

  std::string peer_host = conn->getClient()->getHost();
  uint32_t peer_port = conn->getClient()->getPort();
  std::stringstream ss;
  ss << "http://" << peer_host << ":" << peer_port << "/";
  std::string xmlrpc_uri = ss.str();
  udp_transport = conn->getUDPTransport();

  XmlRpc::XmlRpcValue proto;
  if(!XMLRPCManager::instance()->validateXmlrpcResponse("requestTopic", result, proto))
  {
  	ROSCPP_LOG_DEBUG("Failed to contact publisher [%s:%d] for topic [%s]",
              peer_host.c_str(), peer_port, name_.c_str());
  	closeTransport(udp_transport);
  	return;
  }

  if (proto.size() == 0)
  {
  	ROSCPP_LOG_DEBUG("Couldn't agree on any common protocols with [%s] for topic [%s]", xmlrpc_uri.c_str(), name_.c_str());
  	closeTransport(udp_transport);
  	return;
  }

  if (proto.getType() != XmlRpcValue::TypeArray)
  {
  	ROSCPP_LOG_DEBUG("Available protocol info returned from %s is not a list.", xmlrpc_uri.c_str());
  	closeTransport(udp_transport);
  	return;
  }
  if (proto[0].getType() != XmlRpcValue::TypeString)
  {
  	ROSCPP_LOG_DEBUG("Available protocol info list doesn't have a string as its first element.");
  	closeTransport(udp_transport);
  	return;
  }

  std::string proto_name = proto[0];
  if (proto_name == "TCPROS")
  {
    if (proto.size() != 3 ||
        proto[1].getType() != XmlRpcValue::TypeString ||
        proto[2].getType() != XmlRpcValue::TypeInt)
    {
    	ROSCPP_LOG_DEBUG("publisher implements TCPROS, but the " \
                "parameters aren't string,int");
      return;
    }
    std::string pub_host = proto[1];
    int pub_port = proto[2];
    ROSCPP_LOG_DEBUG("Connecting via tcpros to topic [%s] at host [%s:%d]", name_.c_str(), pub_host.c_str(), pub_port);

//ROS_INFO("here in subscription");

    //ros::TransportTCPPtr transport(new ros::TransportTCP(&ros::PollManager::instance()->getPollSet()));
    ros::TransportTCPPtr transport(new ros::TransportTCP(&poll_manager_->getPollSet()));
    if (transport->connect(pub_host, pub_port))
    {
      ros::ConnectionPtr connection(new ros::Connection());
      TransportPublisherLinkPtr pub_link(new TransportPublisherLink(shared_from_this(), xmlrpc_uri, transport_hints_));

      connection->initialize(transport, false, ros::HeaderReceivedFunc());
      pub_link->initialize(connection);

      ConnectionManager::instance()->addConnection(connection);

      boost::mutex::scoped_lock lock(publisher_links_mutex_);
      addPublisherLink(pub_link);

      ROSCPP_LOG_DEBUG("Connected to publisher of topic [%s] at [%s:%d]", name_.c_str(), pub_host.c_str(), pub_port);
    }
    else
    {
    	ROSCPP_LOG_DEBUG("Failed to connect to publisher of topic [%s] at [%s:%d]", name_.c_str(), pub_host.c_str(), pub_port);
    }
  }
  else if (proto_name == "UDPROS")
  {
    if (proto.size() != 6 ||
        proto[1].getType() != XmlRpcValue::TypeString ||
        proto[2].getType() != XmlRpcValue::TypeInt ||
        proto[3].getType() != XmlRpcValue::TypeInt ||
        proto[4].getType() != XmlRpcValue::TypeInt ||
        proto[5].getType() != XmlRpcValue::TypeBase64)
    {
      ROSCPP_LOG_DEBUG("publisher implements UDPROS, but the " \
	    	       "parameters aren't string,int,int,int,base64");
      closeTransport(udp_transport);
      return;
    }
    std::string pub_host = proto[1];
    int pub_port = proto[2];
    int conn_id = proto[3];
    int max_datagram_size = proto[4];
    std::vector<char> header_bytes = proto[5];
    boost::shared_array<uint8_t> buffer = boost::shared_array<uint8_t>(new uint8_t[header_bytes.size()]);
    memcpy(buffer.get(), &header_bytes[0], header_bytes.size());
    ros::Header h;
    std::string err;
    if (!h.parse(buffer, header_bytes.size(), err))
    {
      ROSCPP_LOG_DEBUG("Unable to parse UDPROS connection header: %s", err.c_str());
      closeTransport(udp_transport);
      return;
    }
    ROSCPP_LOG_DEBUG("Connecting via udpros to topic [%s] at host [%s:%d] connection id [%08x] max_datagram_size [%d]", name_.c_str(), pub_host.c_str(), pub_port, conn_id, max_datagram_size);

    std::string error_msg;
    if (h.getValue("error", error_msg))
    {
      ROSCPP_LOG_DEBUG("Received error message in header for connection to [%s]: [%s]", xmlrpc_uri.c_str(), error_msg.c_str());
      closeTransport(udp_transport);
      return;
    }

    TransportPublisherLinkPtr pub_link(new TransportPublisherLink(shared_from_this(), xmlrpc_uri, transport_hints_));
    if (pub_link->setHeader(h))
    {
      ros::ConnectionPtr connection(new ros::Connection());
      connection->initialize(udp_transport, false, NULL);
      connection->setHeader(h);
      pub_link->initialize(connection);

      ConnectionManager::instance()->addConnection(connection);

      boost::mutex::scoped_lock lock(publisher_links_mutex_);
      addPublisherLink(pub_link);

      ROSCPP_LOG_DEBUG("Connected to publisher of topic [%s] at [%s:%d]", name_.c_str(), pub_host.c_str(), pub_port);
    }
    else
    {
      ROSCPP_LOG_DEBUG("Failed to connect to publisher of topic [%s] at [%s:%d]", name_.c_str(), pub_host.c_str(), pub_port);
      closeTransport(udp_transport);
      return;
    }
  }
  else
  {
  	ROSCPP_LOG_DEBUG("Publisher offered unsupported transport [%s]", proto_name.c_str());
  }
}
Пример #22
0
bool UIWidget::IsRoot() const{
  auto w = window.lock();
  if(!w) return false;
  return w->GetRoot() == shared_from_this();
}
Пример #23
0
void TransportPublisherLink::handleMessage(const SerializedMessage& m, bool ser, bool nocopy)
{
  stats_.bytes_received_ += m.num_bytes;
  stats_.messages_received_++;

  SubscriptionPtr parent = parent_.lock();

  if (parent)
  {
    stats_.drops_ += parent->handleMessage(m, ser, nocopy, getConnection()->getHeader().getValues(), shared_from_this());
  }
}
Пример #24
0
void ValueBindings::add(const ValueBindingPtr& var)
{
    valueBindings.push_back(var);
    var->owner = std::static_pointer_cast<ValueBindings>(shared_from_this());
}
Пример #25
0
 bool Join(Map& map) { return map.insert(Map::value_type(GetIndex(), shared_from_this())).second; }
Пример #26
0
void recruit::accept(visitor& v)
{
	v.visit(shared_from_this());
}
void downloader_instance_simple2::handle_read(const boost::system::error_code& ec, std::size_t length)
{
    if (!ec)
    {
        ostream_.write(buffer_, length);
        readed_bytes_ += length;
        
        if (owner()->progress_notify_)
            owner()->progress_notify_(readed_bytes_);

        {
            boost::mutex::scoped_lock lock(owner()->stateGuard_);

            while (owner()->command_ != http_downloader_simple2::commandNull)
            {
                switch (owner()->command_)
                {
                case http_downloader_simple2::commandPause:
                    {
                        owner()->state_ = http_downloader_simple2::statePaused;
                        owner()->command_ = http_downloader_simple2::commandNull;

                        if (owner()->state_notify_)
                            owner()->state_notify_(http_downloader::statePause);

                        while (
                            owner()->command_ != http_downloader_simple2::commandCancel &&
                            owner()->command_ != http_downloader_simple2::commandResume
                            )   
                        {
                            lock.unlock();
                            boost::this_thread::sleep( boost::posix_time::milliseconds(100) ); 
                            lock.lock();                                                                                                
                        }

                        if (owner()->command_ == http_downloader_simple2::commandResume)
                        {
                            owner()->state_ = http_downloader_simple2::stateDownload;
                            owner()->command_ = http_downloader_simple2::commandNull;
                            if (owner()->state_notify_)
                                owner()->state_notify_(http_downloader::stateResume);
                        }

                    }
                    break;

                case http_downloader_simple2::commandCancel:
                    {
                        owner()->command_ = http_downloader_simple2::commandNull;
                        if (owner()->state_notify_)
                            owner()->state_notify_(http_downloader::stateCancel);
                        return;
                    }
                    break;

                case http_downloader_simple2::commandResume:
                    break;

                }
            }
            
        }

        read_stream_.async_read_some(
            boost::asio::buffer(buffer_),
            boost::bind(&downloader_instance_simple2::handle_read,
            shared_from_this(), _1, _2));
    } 
    else
    {
        if ( boost::asio::error::misc_category == ec.category() )
        {
            if (boost::asio::error::eof == ec.value())
            {
                if (owner()->state_notify_)
                    owner()->state_notify_(http_downloader::stateFinish);    
            }
        }
        else
        {
                if (owner()->state_notify_)
                    owner()->state_notify_(http_downloader::stateError);    
        }
    }
}
Пример #28
0
void TileObject::setPosition(Vec3<float> newPosition)
{
	auto thisPtr = shared_from_this();
	if (!thisPtr)
	{
		LogError("This == null");
	}
	if (newPosition.x < 0 || newPosition.y < 0 || newPosition.z < 0 ||
	    newPosition.x > map.size.x + 1 || newPosition.y > map.size.y + 1 ||
	    newPosition.z > map.size.z + 1)
	{
		LogWarning("Trying to place object at {%f,%f,%f} in map of size {%d,%d,%d}", newPosition.x,
		           newPosition.y, newPosition.z, map.size.x, map.size.y, map.size.z);
		newPosition.x = clamp(newPosition.x, 0.0f, (float)map.size.x + 1);
		newPosition.y = clamp(newPosition.y, 0.0f, (float)map.size.y + 1);
		newPosition.z = clamp(newPosition.z, 0.0f, (float)map.size.z + 1);
		LogWarning("Clamped object to {%f,%f,%f}", newPosition.x, newPosition.y, newPosition.z);
	}
	this->removeFromMap();

	this->owningTile = map.getTile(newPosition);
	if (!this->owningTile)
	{
		LogError("Failed to get tile for position {%f,%f,%f}", newPosition.x, newPosition.y,
		         newPosition.z);
	}

	auto inserted = this->owningTile->ownedObjects.insert(thisPtr);
	if (!inserted.second)
	{
		LogError("Object already in owned object list?");
	}

	int layer = map.getLayer(this->type);

	this->owningTile->drawnObjects[layer].push_back(thisPtr);
	std::sort(this->owningTile->drawnObjects[layer].begin(),
	          this->owningTile->drawnObjects[layer].end(), TileObjectZComparer{});

	Vec3<int> minBounds = {floorf(newPosition.x - this->bounds.x / 2.0f),
	                       floorf(newPosition.y - this->bounds.y / 2.0f),
	                       floorf(newPosition.z - this->bounds.z / 2.0f)};
	Vec3<int> maxBounds = {ceilf(newPosition.x + this->bounds.x / 2.0f),
	                       ceilf(newPosition.y + this->bounds.y / 2.0f),
	                       ceilf(newPosition.z + this->bounds.z / 2.0f)};

	for (int x = minBounds.x; x < maxBounds.x; x++)
	{
		for (int y = minBounds.y; y < maxBounds.y; y++)
		{
			for (int z = minBounds.z; z < maxBounds.z; z++)
			{
				if (x < 0 || y < 0 || z < 0 || x > map.size.x || y > map.size.y || z > map.size.z)
				{
					// TODO: Decide if having bounds outside the map are really valid?
					continue;
				}
				Tile *intersectingTile = map.getTile(x, y, z);
				if (!intersectingTile)
				{
					LogError("Failed to get intersecting tile at {%d,%d,%d}", x, y, z);
					continue;
				}
				this->intersectingTiles.push_back(intersectingTile);
				intersectingTile->intersectingObjects.insert(thisPtr);
			}
		}
	}
	// Quick sanity check
	for (auto *t : this->intersectingTiles)
	{
		if (t->intersectingObjects.find(shared_from_this()) == t->intersectingObjects.end())
		{
			LogError("Intersecting objects inconsistent");
		}
	}
}
Пример #29
0
void proxy::req_get::on_request(const ioremap::thevoid::http_request &req, const boost::asio::const_buffer &buffer) {
	HANDY_TIMER_START("mds.get.time", reinterpret_cast<uint64_t>(this));
	HANDY_MDS_GET();
	m_beg_time = std::chrono::system_clock::now();
	url_str = req.url().path();
	BH_LOG(logger(), SWARM_LOG_INFO, "Get: handle request: %s", url_str.c_str());
	namespace_ptr_t ns;
	try {
		ns = server()->get_namespace(url_str, "/get");
		auto &&prep_session = server()->prepare_session(url_str, ns);
		m_session = prep_session.first;
		m_session->set_timeout(server()->timeout.read);
		m_key = prep_session.second;
		m_key.transform(*m_session);
		m_key.set_id(m_key.id());
	} catch (const std::exception &ex) {
		BH_LOG(logger(), SWARM_LOG_INFO,
			"Get: request = \"%s\"; err: \"%s\"",
			req.url().path().c_str(), ex.what());
		HANDY_MDS_GET_REPLY(400);
		send_reply(400);
		return;
	}

	if (!server()->check_basic_auth(ns->name, ns->auth_key_for_read, req.headers().get("Authorization"))) {
		auto token = server()->get_auth_token(req.headers().get("Authorization"));
		BH_LOG(logger(), SWARM_LOG_INFO,
				"%s: invalid token \"%s\""
				, url_str.c_str(), token.empty() ? "<none>" : token.c_str());
		ioremap::thevoid::http_response reply;
		ioremap::swarm::http_headers headers;

		reply.set_code(401);
		headers.add("WWW-Authenticate", std::string("Basic realm=\"") + ns->name + "\"");
		headers.add("Content-Length", "0");
		reply.set_headers(headers);
		HANDY_MDS_GET_REPLY(reply.code());
		send_reply(std::move(reply));
		return;
	}

	if (m_session->get_groups().empty()) {
		BH_LOG(logger(), SWARM_LOG_INFO
				, "Get %s: on_request: cannot find couple of groups for the request"
				, url_str.c_str());
		HANDY_MDS_GET_REPLY(404);
		send_reply(404);
		return;
	}

	auto query_list = req.url().query();
	m_offset = get_arg<uint64_t>(query_list, "offset", 0);
	m_size = get_arg<uint64_t>(query_list, "size", 0);
	m_if_modified_since = req.headers().get("If-Modified-Since");
	m_first_chunk = true;
	m_chunk_size = server()->m_read_chunk_size;

	{
		std::ostringstream oss;
		oss << "Get " << m_key.remote() << " " << m_key.to_string()
			<< ": lookup from groups [";
		const auto &groups = m_session->get_groups();
		for (auto bit = groups.begin(), it = bit, end = groups.end(); it != end; ++it) {
			if (it != bit) oss << ", ";
			oss << *it;
		}
		oss << ']';
		auto msg = oss.str();
		BH_LOG(logger(), SWARM_LOG_INFO, "%s", msg.c_str());
	}
	{
		auto ioflags = m_session->get_ioflags();
		m_session->set_ioflags(ioflags | DNET_IO_FLAGS_NOCSUM);
		m_session->set_timeout(server()->timeout.lookup);
		m_session->set_filter(ioremap::elliptics::filters::positive);
		auto alr = m_session->quorum_lookup(m_key);
		alr.connect(wrap(std::bind(&proxy::req_get::on_lookup, shared_from_this(),
					std::placeholders::_1, std::placeholders::_2)));
		m_session->set_ioflags(ioflags);
	}
}
void au::SessionTokenTestConnection::ParseHeaders(
        const std::size_t bytes_transferred
    )
{
    const std::string raw_headers([this, bytes_transferred]
    {
        asio::streambuf::const_buffers_type bufs =
            request_->read_buffer_.data();

        return std::string(
            asio::buffers_begin(bufs),
            ( asio::buffers_begin(bufs) + bytes_transferred )
        );
    }());

    std::string line;

    uint64_t content_length = 0;

    std::istream response_stream(&request_->read_buffer_);
    response_stream >> request_->http_method;
    response_stream >> request_->http_request_path;
    response_stream >> request_->http_version;
    std::getline(response_stream, line);

    if ( ! response_stream || request_->http_version.substr(0, 5) != "HTTP/")
    {
        std::cout << "Bad HTTP header." << std::endl;
        request_->Fail(HttpStatusCode::bad_request);
        return;
    }

    std::string last_header_name;
    while (std::getline(response_stream, line) && line != "\r")
    {
        boost::trim_right(line);

        if ( line.empty() ) continue;

        // HTTP headers can be split up inbetween lines.
        // http://www.w3.org/Protocols/rfc2616/rfc2616-sec2.html#sec2.2
        if ( line[0] == ' ' || line[0] == '\t' )
        {
            if ( last_header_name.empty() )
            {
                std::cout << "Bad headers." << std::endl;
                request_->Fail(HttpStatusCode::bad_request);
                return;
            }

            // This is a continuation of previous line.
            auto it = request_->headers.find(last_header_name);
            it->second += " ";
            boost::trim(line);
            it->second += line;

            continue;
        }

        boost::iterator_range<std::string::iterator> result =
            boost::find_first(line, ":");

        if ( ! result.empty() )
        {
            std::string header_name = std::string(
                line.begin(), result.begin());

            std::string header_value = std::string(
                result.end(), line.end());

            boost::trim(header_name);
            boost::to_lower(header_name);

            boost::trim(header_value);

            request_->headers.emplace(header_name, header_value);

            // Record the last header name in case the next line is
            // extended.
            last_header_name.swap(header_name);
        }
    }

    {
        auto it = request_->headers.find("content-length");
        if ( it != request_->headers.end() )
        {
            try {
                content_length = boost::lexical_cast<uint64_t>(
                    it->second);
            } catch(boost::bad_lexical_cast &) {
                std::cout << "Invalid content length." << std::endl;
                request_->Fail(HttpStatusCode::bad_request);
                return;
            }
        }
    }

    std::vector<std::string> request_path_parts;
    boost::split(
        request_path_parts,
        request_->http_request_path,
        boost::is_any_of("?"));

    if ( request_path_parts.size() > 2 )
    {
        std::cout << "Bad request path: " << request_->http_request_path
            << std::endl;
        request_->Fail(HttpStatusCode::bad_request);
        return;
    }

    request_->path = request_path_parts[0];

    auto handler_it = handlers_->find( request_->path );
    if ( handler_it == handlers_->end() )
    {
        std::cout << "Server error: no handler for path: " << request_->path
            << std::endl;
        request_->Fail(HttpStatusCode::not_found);
        return;
    }

    if ( request_path_parts.size() > 1 )
    {
        request_->query = request_path_parts[1];

        std::vector<std::string> query_parts;
        boost::split(
            query_parts,
            request_->query,
            boost::is_any_of("&"));

        for ( const std::string & part : query_parts )
        {
            std::vector<std::string> key_pair;
            boost::split(
                key_pair,
                part,
                boost::is_any_of("="));

            boost::optional<std::string> key = get_parameter::Decode(
                key_pair[0] );
            if ( ! key )
            {
                std::cout << "Got bad url data." << std::endl;
                request_->Fail(HttpStatusCode::bad_request);
                return;
            }

            if (key_pair.size() > 1)
            {
                boost::optional<std::string> value = get_parameter::Decode(
                    key_pair[1] );
                if ( ! value )
                {
                    std::cout << "Got bad url data." << std::endl;
                    request_->Fail(HttpStatusCode::bad_request);
                    return;
                }

                request_->query_parts[*key] = *value;
            }
            else
                request_->query_parts[*key] = "";
        }
    }

    if ( content_length > 0 )
    {
        auto self(shared_from_this());

        // Empty buffer for reuse
        request_->read_buffer_.consume( request_->read_buffer_.size() );

        asio::async_read(
            request_->ssl_stream,
            request_->read_buffer_,
            asio::transfer_exactly(content_length),
            boost::bind(
                &au::SessionTokenTestConnection::HandleContentRead,
                shared_from_this(),
                asio::placeholders::bytes_transferred,
                asio::placeholders::error
            )
        );
    }
    else
    {
        // Execute the handler.
        (handler_it->second)(std::move(request_));
    }
}