I'm looking lua memcached client that supports memcached binary protocol.
Could you recommend something?
There is a client that supports memcached binary protocol.
lua-resty-couchbase - Lua couchbase client driver for the ngx_lua based on the cosocket API.
Not sure about binary protocol, but check this out: https://github.com/silentbicycle/lua-memcached
Also, this one may serve as a reference (it is for ngx_lua, so it is unlikely that you'll be able to immediately reuse it out of the box): https://github.com/agentzh/lua-resty-memcached
I did not try either of the modules, please do leave feedback here in comments if you will try them.
I've publish lua binary client:
http://github.com/kolchanov/Lua-couchbase
Related
I know that there exists documentation for migrating ES7 clients from [TransportClient to HighLevelRestClient] and [HighLevelRestClient to API client]. But I want to check if it is possible to directly migrate from [TransportClient to APIClient]
Is this even possible ?
If Yes, is there any documentation ?
Yes It is possible to upgrade from Transport client to Java API Client. No there is no official documentation for the upgrade process from transport client to Java API client as the official full documentation of java api client itself hasn't been released.
Please refer to this issue at the Elastic Forum:https://discuss.elastic.co/t/upgrade-from-transport-client-to-hlrc-java-api-client-which-to-choose/320869
I hope this clears your doubt regarding what approach you should take now.
In general, supposing your server, written in Javascript in the node.js environment, is assembling a response to an end user from services provided by other servers, is there any reasonable alternative to having them all talk JSON?
RPC calls usually use XDR, which is binary, or JSON, which is ascii. There are handy libraries to take care of all the boring sockets stuff for you for these cases.
Node.js tools to use RPC are available for RPC in JSON, but is there any easy way to access RPC calls in binary formats such as XDR, ASN.1 PER, or Avro Apache from node.js. Or to do something similar?
I am not asking what is the best way, or what can be done, because anything can be done with enough hard work, but rather what ways have standards to avoid reinventing the wheel, and libraries to do as much of the work as possible.
avsc implements Avro's RPC specification, you can use it to expose "type-safe" services over any transport (e.g. HTTP, TCP, WebSockets). The quickstart guide goes through a simple example that should help you get started. (Disclaimer: I wrote it.)
Does TCL provides a functionality to listen to external servers?
I want to create a socket with TCL-based client-side, which gonna listen to not TCL-based server-side. In the common case I'm gonna send XML (SOAP) message and I'm gonna wait for some response, which gonna be some kind of mask.
If TCL does support such functionality, please help me with some hyper-links to already existing API's or some other posts!
Any help is useful! Thanks in advance!
Tcl does support sockets. You can either write your own WS client implementation using the socket command, you can use the Tcl http package, or the TclSoap library as #Johannes13 suggested.
We're designing a communications system for supporting asynchronous near-realtime server pushing of events/messages to thousands of clients acrros JVM, .Net and mobile platforms. We have a mixed model (both publish-subscribe and request-response) and binary data.
We are using Netty and Google Protocol Buffers and we need to encapsulate all this in http(s).
We were looking into the Bayeux Protocol and its Netty implementation and were inclined to use a modified version of it with protobuf codecs instead of JSONs' or roll our own starting from the WebSockets example (client and server). For performance concerns we would stay out of Base64 encodings an the like.
Are there any implementations that we are missing? How feasible would it be to do a protobuf-based Bayeux protocol? Any pointers are greatly appreciated.
How about STOMP over Web Sockets?
Is there any way to override Win32 File API such as CreateFile()? I want my app to see a virtual file solely for my app, however, the virtual file does not exist actually.
There exist two approaches - with a kernel-mode driver (documented one) and without such driver (a hacky way).
With a kernel-mode driver you have two ways - (1) create a virtual filesystem driver (or take existing one) and (2) create a filesystem filter driver (or take existing one). Driver development = a year or so of work to do right and completely. Driver development is fully documented in MSDN.
Without a kernel-mode driver you need to employ API hooking. Libraries such as Detours, MadCodeHook and Boxedapp SDK do this (and let you do this as well).
Hooking an API topic is quite large to describe it here fully, but there's a good CodeProject article on this topic.
System-wide? Bad idea. If it's just your app, don't use the standard APIs and implement it yourself. But if the data must persist between sessions, you'll have to store the data somewhere (file, registry, etc.).