I use pusher.com and want to migrate to my own hosting. Is there a library that implements the Pusher.com protocol in Node.js?
Slanger is an open source implementation of the Pusher protocol written in Ruby; I'm not familiar with one written in Node. Note that the protocol is fairly documented, so if you really needed it for Node you could potentially write one.
Related
There is TDlib which allows to work with Telegram Client API.
Documentation says that it's possible to use it with almost any language.
I can't imagine myself how I can use it with Node.js
Could you tell me where to start from or provide me with a sample code?
You can make requests and get updates using td_json_client and node-ffi interfaces. Official repository provides a simple example.
If you don't want to create API client from zero, you may use one of exists. For example, check out Airgram. This is a strong typed tdlib client for NodeJS.
You can probably port one of the examples on their GitHub repos (Python can be an easy one). You needs to learn how to use binary modules with node.
Or you can check one of the 3rd party libraries (eg. https://github.com/k-egor-smirnov/node-tg-native)
There are 2 active TDLib wrappers in Node.js:
https://github.com/airgram/airgram
https://github.com/Bannerets/tdl
Both require you to build the TDLib binary yourself before using these wrapper: https://tdlib.github.io/td/build.html
I want to make small chat app in nodejs.
But every where i found that to achieve this functionality node is used with socket.io
As node was also created with push notification in mind so thinking
How to create chat app purely in node if possible ?
Thanks!
I want to make small chat app in nodejs. But every where i found that
to achieve this functionality node is used with socket.io. As node
was also created with push notification in mind so thinking How to
create chat app purely in node if possible ?
Yes, it is possible to create a node.js application that supports chat without using socket.io. You have these choices:
Use a straight webSocket to "push" to the client. You will need to find or write your own server-side code for handling the webSocket protocol because such code is not built into node by default. The ws module is one such library. If using a plain webSocket, you will likely have to implement on your own some of the functionality that socket.io implements such as auto-reconnect.
Find some other library (besides socket.io) that is built on top of a webSocket that would let you push data to a client.
Invent your own substitute for a webSocket (probably client polling or long polling) and code that. This is what was done before webSockets existed. It is much less efficient than a continuously connected webSocket.
All of these choices involve writing some code that has already been written for you in socket.io so most developers would rather just use the already working and already tested solution rather than reimplement it themselves.
To get into further detail in your question, you will need to define what "purely in node" means to really answer this question. That's not a well defined term. The socket.io library is just a library written in Javascript just like thousands of other libraries you can use in node.js to get your job done.
As you quickly see with node programming, you can't do very much at all in a default node instance without loading other libaries. Some of these libraries come with a default installation of node (like the fs library or http library, for example) and others are libraries that you install before using (usually as simple as typing "npm install socket.io") and then var io = require("socket.io");.
If you are not going to use the socket.io library, then you need a mechanism for "pushing" data to a client in order to make a chat application work. The only true "push" that has any cross-browser support is a webSocket. A webSocket is what socket.io uses. You could use a webSocket from node without using socket.io, but you'd have to write or find code that implements the webSocket protocol that you can run on node (the ws module is one such library). Such code is not built into node by default.
If you weren't going to use webSocket, then there is no other cross-browser method to "push" data to a browser client. Your only other alternative I'm aware of would be browser polling which isn't actual push, but tries to simulate push by just regularly asking the server if the server has anything new for a particular client. An enhancement to straight polling is "long polling" which was invented before we had actual push with webSockets.
All of this problem has already been solved in socket.io so unless you really just want your own research project to rebuilt similar functionality in your own code, you may as well build on solutions that have already been done by using something like the socket.io library.
If you have some specific objection to the socket.io library, then please explain that objection so we can understand what your real goal is here.
Node.js doesn't come with an out-of-the-box server-side Websocket implementation, so you will have to, at least, introduce a package which does.
If you don't want to go with socket.io, you can then defer to ws, which is what socket.io uses under the hood.
I'm using node.js+socket.io in my projects, and one of the issues that bothers me the most is absence of normal AS3 library than can handle communications between as3 and node.js using socket.io.
In my last project, I used https://github.com/simb/FlashSocket.IO this library, but I had to roll back to node.js v0.8.25.
So - requirements:
Works with node.js v0.10.x
Works with socket.io v0.9.x
Secure connection support (wss)
It would be nice to have more than one library, maybe someone knows a better one?
Thanks!
I also needed this, so here's what I used: https://github.com/sinnus/socket.io-flash.
requires Socket.IO(>= v.0.8)
I have a multiserver multiclient application and I would like to keep some common data managed by a single daemon (to avoid a nightmare f concurrency), so the servers can just ask it when they need to manipulate the shared data.
I am already using libevent in the servers so I would like to stick to it and use it's RPC framework but I could not find an example of it used in real world.
Google Protobuf provides a RPC framework. And it is also used inside Google for RPC and many other things.
Protobuf is a library for data exchanging.
It handles data serialization, deserialization, compression, and so on.
It is created and opensourced by Google.
However, they didn't opensource the part of RPC implementation.
It only provides a framework.
You can integrate Protobuf with your existing libevent program.
I have personally implemented a RPC with Protobuf and libev(which is a similar project to libevent). And they work fine.
I want to work with WebSockets in Node.js web app, and I am looking for the easiest way to do this. I've seen so many github repositories seemingly providing some ease of use.
But, I'm just looking to see if there's one that stands out as having the most support, or most widely implemented.
I was kind of leaning towards Socket.IO but I'm not entirely sure.
Any advice?
Thanks!
use now now or socket.io.
now is an abstraction build on socket.io which allows you to define methods on a shared object across client and server. This means you dont have to interact with the stream manually and can just seemingly call methods. Do read their best practices before use though.
now also has a grouping system in build which means you can talk to clients in groups rather then one or all.
socket.io itself is recommended because of it's excellent browser support with its range of fallbacks. It's also owned/maintained by a node.js startup so it's more likely to be maintained in the future. And it also has a range of server-side socket.io implementations for platforms other then node.js so you can use the same API on multiple platforms.
If you find socket.IO too large or bloated you can go for the lightweight websocket-server. This is just a simple websocket implementation and is reasonably stable. I have personally used this if I want something which is a very minimal abstraction and if I want more low level access to the websocket server itself.
Take a look at this blog post, it's very informative...