geniusesgroup / memar-go

Developing software framework for the GO programming language

Memar - Golang version

Memar as a Go language library is a repository wrapper to store all implementation of Memar and others protocols and algorithms to make a digital software more easily in better performance. You can use all packages exported APIs, go generator mechanism or by library commands to access some useful APIs from command line easily.

If you want to get insight about memar, You MUST start reading interfaces in protocol package.

Installation

• Make project directory and suggest use your internet domain name for it.
• initialize project version control. If you use git run git init or git clone ${repository path}.
• init go project by go mod init
• add memar to your project dependency
• install memar with lang_eng or your desire language
• initialize the project with desire domain e.g. google.com
• Complete manifest in main package.
• Add other data to main package if needed.
• Implement protocols logic by autogenerate some codes not write them manually.
• build your organization app with desire tags and target OS and hardwares.
• run your desire version from /bin/ directory. Strongly suggest run app by systemd on linux or other app manager on other OS.

or easily run the following command under your project, just replace your domain name.

mkdir {domain}
git init
go mod init
go get -u github.com/GeniusesGroup/memar-go
go install github.com/GeniusesGroup/memar-go -tags "lang_eng"
memar app init -d={domain}
memar app build

Commands (CLA)

memar has a the command-line client for the some generator APIs implement in modules. It provides simple access to all APIs functions to make an application, a GUI app, ....

You can get list of all commands and their helps with memar help. We just list some of important commands here that you can run them from within a Go module or any where in your project directory:

• Initialize a project: memar app init -idn=[internet-domain-name]
• Add new domain module: memar mod new -dn=[domain-name]
• Build the apps(os images): memar app build
• Run the app(os image): memar app run

Build tags

• dev_mode: first check and change AppMode_Dev const in protocol package to desire behavior
• tcp_listener:

Code style

Read more here

Contribution Guide

• Referencing issues

memar-go's Issues

[net/http] Decode problem with bad streams in Non TLS streams

Based on this question HTTP package doesn't work properly when giving stream return part of the data(first line+headers).

It works on many OSs and situations as tested in real applications by us, But Need to fix it.

[service] Improve service finding by ID performance

In this file use GO map as hash table to store and find services by ID but GO map is not effient for simple uint64 type as key! Improve this file by implement internal custom table.

• Don't use array pointer for buckets due to it is most read table with over 99.9% times.
  
• Don't use overflow map||buckets and block procces to expand whole hash table.

[net] Combine readTimer and writeTimer to improve performance

To achieve this, we must have two when monotonic.Time fields and one timer.Async instead of two timer.Async. But first need some benchmark to prove the idea.

[net/tcp] Continue package development

Someone must take responsibility for implementing TCP protocol in user space. I have developed some parts of it but it is not ready to use.
We know that we can't easily port existing code because when TCP is handled on userspace, we must think differently from kernel-level implementation.

[modules/storage] Implement interface to SQL service

Hints:

• At least need three services: generate mysql.sql, generate mysql.go, and generate volatile-memory.go files.
• Input example:

// Storage_Fields indicates the domain record data fields.
type Storage_Fields interface {
	RequestID() UserRequestUUID //
	DomainID() uint64           // Domain MediaTypeID e.g. product, content, ... domain
	ServiceID() uint64          //
	UserID() protocol.UserID    // user domain
	UserConnectionID() [16]byte // Store to remember which request belongs to which Connection/AppInstance.
	Time() protocol.Time // Request time or save Time of the request not the created record by this record.
}

// Storage_Services indicates the domain storage layer services.
type Storage_Services interface {
	Save(sf Storage_Fields) (err protocol.Error)

	Get(requestID UserRequestUUID, vo protocol.VersionOffset) (sf Storage_Fields, err protocol.Error)

	FindByDomain(domainID uint64, offset, limit uint64) (requestIDs []UserRequestUUID, err protocol.Error)
	FindByUser(userID [16]byte, offset, limit uint64) (requestIDs []UserRequestUUID, err protocol.Error)
}

• Develop to easily add support for multiple storage engines (other than SQL based) in future
• generate MySQL, Postgres, ... optimized SQL not general SQL codes
• Use SQL procedure for queries not send a query in each request.

Problems need to fix in comparison to other modules:

• As long as it is possible logic must be in compile-time not runtime.
• Respect object life cycle and abstraction patterns. e.g. Initiliaze of each domain storage must take place in that domain, not the main of the application.
• All existing modules in the Go ecosystem force the developer to write the storage layer handly! we need to write efficient codes for the storage layer by given storage interfaces.
  It means we don't need these fancy things:

users, err := models.Users(
  Select("id", "name"),
  InnerJoin("credit_cards c on c.user_id = users.id"),
  Where("age > ?", 30),
  AndIn("c.kind in ?", "visa", "mastercard"),
  Or("email like ?", `%aol.com%`),
  GroupBy("id", "name"),
  Having("count(c.id) > ?", 2),
  Limit(5),
  Offset(6),
).All(ctx, db)

other modules:

• Cheikhshift Online Tool - Code
• https://github.com/kyleconroy/sqlc
• https://github.com/volatiletech/sqlboiler
• https://entgo.io/docs/getting-started/
• sqlc is the opposite of our way! the sqlc forces developers to write SQL files, but we force them to write some interfaces to generate both SQL and storage layer logic.
• sal - article
• http://doug-martin.github.io/goqu/

[modules] Generate context-mapping

As describe here develope a module to generate context-mapping for application modules.

[time/unix] Move assembly codes from go/src/runtime

Move assembly logic from go/src/runtime to the package to prevent use unsafe package.

[table/...] Start develope some data structure

"Go" has introduced Generic development, we need some efficient table data structure that can be used in many other packages e.g. #2, #7, ...

Also, We can move buffer package ideas to table/... and not use buffer words anymore.

[time/monotonic] Move assembly codes from go/src/runtime

Move assembly logic from go/src/runtime to the package to prevent use unsafe package.