Ergo Versions Save

This release includes fixes:

• Fixed incorrect handling of gen.SupervisorStrategyRestartTransient restart strategy in gen.Supervisor
• Fixed missing ServerBehavior in [gen.Pool, gen.Raft, gen.Saga, gen.Stage, gen.TCP, gen.UDP, gen.Web] behavior interfaces
• Introduced the new tool for boilerplate code generation - ergo https://github.com/ergo-services/tools. You may read more information about this tool in our article with a great example https://blog.ergo.services/quick-start-1094d56d4e2

This release includes fixes:

• Improved gen.TCP. Issue #152
• Fixed incorrect decoding registered map type using etf.RegisterType
• Fixed race condition on process termination. Issue #153

• Introduced gen.Pool. This behavior implements a basic design pattern with a pool of workers. All messages/requests received by the pool process are forwarded to the workers using the "Round Robin" algorithm. The worker process is automatically restarting on termination. See example here examples/genpool
• Removed Erlang RPC support. A while ago Erlang has changed the way of handling this kind of request making this feature more similar to the regular gen.Server. So, there is no reason to keep supporting it. Use a regular way of messaging instead - gen.Server.
• Fixed issue #130 (StartType option in gen.ApplicationSpec is ignored for the autostarting applications)
• Fixed issue #143 (incorrect cleaning up the aliases belonging to the terminated process)

• Now you can join your services made with Ergo Framework into a single cluster with transparent networking using our Cloud Overlay Network where they can connect to each other smoothly, no matter where they run - AWS, Azure or GCP, or anywhere else. All these connections are secured with end-to-end encryption. Read more in this article https://blog.ergo.services/cloud-overlay-network-3a133d47efe5. Here is an example of this feature in action examples/cloud
• examples moved to https://github.com/ergo-services/examples
• Added support Erlang OTP/25
• Improved handling nil values for the registered types using etf.RegisterType(...)
• Improved self-signed certificate generation
• Introduced ergo.debug option that enables extended debug information for lib.Log(...)/lib.Warning(...)
• Fixed gen.TCP and gen.UDP (missing callbacks)
• Fixed ETF registering type with etf.Pid, etf.Alias or etf.Ref value types
• Fixed Cloud client
• Fixed #117 (incorrect handshake process finalization)
• Fixed #139 (panic of the gen.Stage partition dispatcher)

• Introduced gen.Web behavior. It implements Web API Gateway pattern is also sometimes known as the "Backend For Frontend" (BFF). See example examples/genweb
• Introduced gen.TCP behavior - socket acceptor pool for TCP protocols. It provides everything you need to accept TCP connections and process packets with a small code base and low latency. Here is simple example examples/gentcp
• Introduced gen.UDP - the same as gen.TCP, but for UDP protocols. Example is here examples/genudp
• Introduced Events. This is a simple pub/sub feature within a node - any gen.Process can become a producer by registering a new event gen.Event using method gen.Process.RegisterEvent, while the others can subscribe to these events using gen.Process.MonitorEvent. Subscriber process will also receive gen.MessageEventDown if a producer process went down (terminated). This feature behaves in a monitor manner but only works within a node. You may also want to subscribe to a system event - node.EventNetwork to receive event notification on connect/disconnect any peers.
• Introduced Cloud Client - allows connecting to the cloud platform https://ergo.sevices. You may want to register your email there, and we will inform you about the platform launch day
• Introduced type registration for the ETF encoding/decoding. This feature allows you to get rid of manually decoding with etf.TermIntoStruct for the receiving messages. Register your type using etf.RegisterType(...), and you will be receiving messages in a native type
• Predefined set of errors has moved to the lib package
• Updated gen.ServerBehavior.HandleDirect method (got extra argument etf.Ref to distinguish the requests). This change allows you to handle these requests asynchronously using method gen.ServerProcess.Reply(...)
• Updated node.Options. Now it has field Listeners (type node.Listener). It allows you to start any number of listeners with custom options - Port, TLS settings, or custom Handshake/Proto interfaces
• Fixed build on 32-bit arch
• Fixed freezing on ARM arch #102
• Fixed problem with encoding negative int8
• Fixed #103 (there was an issue on interop with Elixir's GenStage)
• Fixed node stuck on start if it uses the name which is already taken in EPMD
• Fixed incorrect gen.ProcessOptions.Context handling

This release includes fixes:

• Fixed problem with encoding negative int8 - critical issue
• Fixed #103 (there was an issue on interop with Elixir's GenStage)
• Fixed node stuck on start if it uses the name which is already taken in EPMD

• Introduced compression feature support. Here are new methods and options to manage this feature:
  • gen.Process:
    • SetCompression(enable bool), Compression() bool
    • SetCompressionLevel(level int), CompressionLevel() int
    • SetCompressionThreshold(threshold int), CompressionThreshold() int messages smaller than the threshold will be sent with no compression. The default compression threshold is 1024 bytes.
  • node.Options:
    • Compression these settings are used as defaults for the spawning processes
  • this feature will be ignored if the receiver is running on either the Erlang or Elixir node
• Introduced proxy feature support with end-to-end encryption.
  • node.Node new methods:
    • AddProxyRoute(...), RemoveProxyRoute(...)
    • ProxyRoute(...), ProxyRoutes()
    • NodesIndirect() returns list of connected nodes via proxy connection
  • node.Options:
    • Proxy for configuring proxy settings
  • includes support (over the proxy connection): compression, fragmentation, link/monitor process, monitor node
  • example examples/proxy.
  • this feature is not available for the Erlang/Elixir nodes
• Introduced behavior gen.Raft. It's improved implementation of Raft consensus algorithm. The key improvement is using quorum under the hood to manage the leader election process and make the Raft cluster more reliable. This implementation supports quorums of 3, 5, 7, 9, or 11 quorum members. Here is an example of this feature examples/raft.
• Introduced interfaces to customize network layer
  • Resolver to replace EPMD routines with your solution (e.g., ZooKeeper or any other service registrar)
  • Handshake allows customizing authorization/authentication process
  • Proto provides the way to implement proprietary protocols (e.g., for IoT area)
• Other new features:
  • gen.Process new methods:
    • NodeUptime(), NodeName(), NodeStop()
  • gen.ServerProcess new method:
    • MessageCounter() shows how many messages have been handled by the gen.Server callbacks
  • gen.ProcessOptions new option:
    • ProcessFallback allows forward messages to the fallback process if the process mailbox is full. Forwarded messages are wrapped into gen.MessageFallback struct. Related to issue #96.
  • gen.SupervisorChildSpec and gen.ApplicationChildSpec got option gen.ProcessOptions to customize options for the spawning child processes.
• Improved sending messages by etf.Pid or etf.Alias: methods gen.Process.Send, gen.ServerProcess.Cast, gen.ServerProcess.Call now return node.ErrProcessIncarnation if a message is sending to the remote process of the previous incarnation (remote node has been restarted).
• Introduced type gen.EnvKey for the environment variables
• All spawned processes now have the node.EnvKeyNode variable to get access to the node.Node value.
• Improved performance of local messaging (up to 8 times for some cases)
• Important node.Options has changed. Make sure to adjust your code.
• Fixed issue #89 (incorrect handling of Call requests)
• Fixed issues #87, #88 and #93 (closing network socket)
• Fixed issue #96 (silently drops message if process mailbox is full)
• Updated minimal requirement of Golang version to 1.17 (go.mod)
• We still keep the rule Zero Dependencies

This release includes fixes:

• critical issue #89 (incorrect handling errors during a Call request)
• issue #87 (incorrect link termination with EPMD).

This release has a minor fix

• #83 fix incorrect allocation of connection handlers

We have to make another release of v2.0.0 due to https://go.dev/blog/v2-go-modules. More details here https://github.com/ergo-services/ergo#versioning

• Added support of Erlang/OTP 24 (including Alias feature and Remote Spawn introduced in Erlang/OTP 23)
• Important: This release includes refined API (without backward compatibility) for a more convenient way to create OTP-designed microservices. Make sure to update your code.
• Important: Project repository has been moved to https://github.com/ergo-services/ergo. It is still available on the old URL https://github.com/halturin/ergo and GitHub will redirect all requests to the new one (thanks to GitHub for this feature).
• Introduced new behavior gen.Saga. It implements Saga design pattern - a sequence of transactions that updates each service state and publishes the result (or cancels the transaction or triggers the next transaction step). gen.Saga also provides a feature of interim results (can be used as transaction progress or as a part of pipeline processing), time deadline (to limit transaction lifespan), two-phase commit (to make distributed transaction atomic). Here is example examples/gensaga.
• Introduced new methods Process.Direct and Process.DirectWithTimeout to make direct request to the actor (gen.Server or inherited object). If an actor has no implementation of HandleDirect callback it returns ErrUnsupportedRequest as a error.
• Introduced new callback HandleDirect in the gen.Server interface as a handler for requests made by Process.Direct or Process.DirectWithTimeout. It should be easy to interact with actors from outside.
• Introduced new types intended to be used to interact with Erlang/Elixir
  • etf.ListImproper to support improper lists like [a|b] (a cons cell).
  • etf.String (an alias for the Golang string) encodes as a binary in order to support Elixir string type (which is binary() type)
  • etf.Charlist (an alias for the Golang string) encodes as a list of chars []rune in order to support Erlang string type (which is charlist() type)
• Introduced new methods Node.ProvideRemoteSpawn, Node.RevokeRemoteSpawn, Process.RemoteSpawn.
• Introduced new interfaces Marshaler (method MarshalETF) and Unmarshaler (method UnmarshalETF) for the custom encoding/decoding data.
• Improved performance for the local messaging (up to 3 times for some cases)
• Added example examples/http to demonsrate how HTTP server can be integrated into the Ergo node.
• Added example examples/gendemo - how to create a custom behavior (design pattern) on top of the gen.Server. Take inspiration from the gen/stage.go or gen/saga.go design patterns.
• Added support FreeBSD, OpenBSD, NetBSD, DragonFly.
• Fixed RPC issue #45
• Fixed internal timer issue #48
• Fixed memory leaks #53
• Fixed double panic issue #52
• Fixed Atom Cache race conditioned issue #54
• Fixed ETF encoder issues #64 #66