core.base #

context & sessions

Everything we do in hero lives in a context, each context has a unique name.

Redis is used to manage the contexts and the sessions.

• redis db 0
• context:current curent id of the context, is also the DB if redis if redis is used
• redis db X, x is nr of context
• context:name name of this context
• context:secret secret as is used in context (is md5 of original config secret)
• context:privkey secp256k1 privkey as is used in context (encrypted by secret)
• context:params params for a context, can have metadata
• context:lastid last id for our db
• session:$id the location of session
• session:$id:params params for the session, can have metadata

Session id is $contextid:$sessionid (e.g. 10:111)

The SessionNewArgs:

• context_name string = 'default'
• session_name string //default will be an incremental nr if not filled in
• interactive bool = true //can ask questions, default on true
• coderoot string //this will define where all code is checked out

import freeflowuniverse.crystallib.core.base

mut session:=context_new(
    coderoot:'/tmp/code'
    interactive:true
)!

mut session:=session_new(context:'default',session:'mysession1')!
mut session:=session_new()! //returns default context & incremental new session

fn configurator_new[T](args ConfiguratorArgs) !Configurator[T]

name is e.g. mailclient (the type of configuration setting) instance is the instance of the config e.g. kds the context defines the context in which we operate, is optional will get the default one if not set

fn context() !&Context

fn context_get(id u32) !&Context

fn context_new(args_ ContextConfigArgs) !&Context

configure a context object params: .

id		   u32 //if not set then redis will get a new context id
name        string = 'default'
params      string
coderoot    string
interactive bool
secret      string
priv_key_hex string //hex representation of private key

fn context_select(id u32) !&Context

fn (mut self BaseConfig[T]) session() !&Session

fn (mut self BaseConfig[T]) configurator() !&Configurator[T]

management class of the configs of this obj

fn (mut self BaseConfig[T]) config_set(myconfig T) !

will overwrite the config

fn (mut self BaseConfig[T]) config_new() !&T

fn (mut self BaseConfig[T]) config() !&T

fn (mut self BaseConfig[T]) config_get() !&T

fn (mut self BaseConfig[T]) config_save() !

fn (mut self BaseConfig[T]) config_delete() !

fn (mut self BaseConfig[T]) init(configtype string, instance string, action Action, myconfig T) !

init our class with the base session_args

fn (mut self Configurator[T]) set(args T) !

set the full configuration as one object to dbconfig

fn (mut self Configurator[T]) exists() !bool

fn (mut self Configurator[T]) new() !T

fn (mut self Configurator[T]) get() !T

fn (mut self Configurator[T]) delete() !

fn (mut self Configurator[T]) getset(args T) !T

fn (mut self Configurator[T]) list() ![]string

fn (mut self Configurator[T]) configprint(args PrintArgs) !

enum Action {
	set
	get
	new
	delete
}

enum ErrorType {
	uknown
	value
}

enum LogType {
	stdout
	error
}

struct Base {
	configtype string @[required]
mut:
	instance string
	session_ ?&Session
}

fn (mut self Base) session() !&Session

struct BaseConfig[T] {
mut:
	configurator_ ?Configurator[T] @[skip; str: skip]
	config_       ?&T
	session_      ?&Session @[skip; str: skip]
	configtype    string
pub mut:
	instance string
}

is an object which has a configurator, session and config object which is unique for the model T is the Config Object

struct Configurator[T] {
pub mut:
	// context     &Context @[skip; str: skip]
	instance    string
	description string
	configured  bool
	configtype  string // e.g. sshclient
}

struct ConfiguratorArgs {
pub mut:
	// context  &Context // optional context for the configurator
	instance string @[required]
}

struct Context {
mut:
	// priv_key_     ?&secp256k1.Secp256k1 @[skip; str: skip]
	params_       ?&paramsparser.Params
	dbcollection_ ?&dbfs.DBCollection @[skip; str: skip]
	redis_        ?&redisclient.Redis @[skip; str: skip]
pub mut:
	// snippets     map[string]string
	config ContextConfig
}

fn (mut self Context) dbcollection() !&dbfs.DBCollection

return db collection

fn (self Context) guid() string

fn (mut self Context) hero_config_exists(cat string, name string) bool

fn (mut self Context) hero_config_get(cat string, name string) !string

fn (mut self Context) hero_config_set(cat string, name string, content_ string) !

fn (self Context) id() string

fn (mut self Context) load() !

get context from out of redis

fn (self Context) name() string

fn (mut self Context) params() !&paramsparser.Params

return the gistructure as is being used in context

fn (mut self Context) redis() !&redisclient.Redis

pub fn (mut self Context) heroscript() !string { panic("implement") mut out := '!!core.context_define ${self.str2()}\n' mut p:=self.params()! if !p.empty() { out += '\n!!core.params_context_set' out += texttools.indent(p.heroscript(), ' ') + '\n' } // if self.snippets.len > 0 { // for key, snippet in self.snippets { // out += '\n!!core.snippet guid:${self.guid()} name:${key}' // out += texttools.indent(snippet.heroscript()," ") + '\n' // } // } return out }

fn (mut self Context) save() !

fn (mut self Context) secret_configure() !

show a UI in console to configure the secret

fn (mut self Context) secret_decrypt(txt string) !string

fn (mut self Context) secret_encrypt(txt string) !string

will use our secret as configured for the hero to encrypt, uses base64

fn (mut self Context) secret_get() !string

fn (mut self Context) secret_set(secret_ string) !

unhashed secret

fn (mut context Context) session_get(args_ ContextSessionGetArgs) !Session

fn (mut context Context) session_latest() !Session

fn (mut context Context) session_new(args_ SessionConfig) !Session

get a session object based on the name / params:

name string

struct ContextConfig {
pub mut:
	id          u32 @[required]
	name        string = 'default'
	params      string
	coderoot    string
	interactive bool
	secret      string // is hashed secret
	priv_key    string // encrypted version
	db_path     string // path to dbcollection
	encrypt     bool
}

struct ContextConfigArgs {
pub mut:
	id           u32
	name         string = 'default'
	params       string
	coderoot     string
	interactive  bool
	secret       string
	encrypt      bool
	priv_key_hex string // hex representation of private key
}

struct ContextSessionGetArgs {
pub mut:
	name string
}

struct ErrorArgs {
pub mut:
	cat       string
	error     string
	errortype ErrorType
}

struct ErrorItem {
pub mut:
	time      ourtime.OurTime
	cat       string
	error     string
	errortype ErrorType
	session   string // the unique name for the session
}

struct LogArgs {
pub mut:
	cat     string
	log     string @[required]
	logtype LogType
}

struct LogItem {
pub mut:
	time    ourtime.OurTime
	cat     string
	log     string
	logtype LogType
	session string
}

fn (li LogItem) str() string

struct Logger {
pub mut:
	session string
}

struct PrintArgs {
pub mut:
	name string
}

struct Session {
pub mut:
	name        string // unique id for session (session id), can be more than one per context
	interactive bool = true
	params      paramsparser.Params
	start       ourtime.OurTime
	end         ourtime.OurTime
	context     &Context @[skip; str: skip]
	config      SessionConfig
	env         map[string]string
}

fn (self Session) check() !

//////// REPRESENTATION

fn (mut self Session) db_config_get() !dbfs.DB

get the db of the config, is unique per context

fn (mut self Session) db_get() !dbfs.DB

get db of the session, is unique per session

fn (mut self Session) env_delete(key string)

Delete an environment variable

fn (mut self Session) env_get(key string) !string

Get an environment variable

fn (mut self Session) env_set(key string, value string) !

Set an environment variable

fn (mut session Session) error(args_ ErrorArgs) !ErrorItem

fn (self Session) guid() string

fn (mut self Session) load() !

load the params from redis

fn (mut session Session) log(args_ LogArgs) !LogItem

cat & log are the arguments . category can be any well chosen category e.g. vm

fn (session Session) logger_new() !Logger

fn (mut self Session) save() !

save the params to redis

struct SessionConfig {
pub mut:
	name        string // unique name for session (id), there can be more than 1 session per context
	start       string // can be e.g. +1h
	description string
	params      string
}