go-ml-dev/dyl

//
//Package dl implements loading shared libraries and binding functions
//

package dyl

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "github.com/ulikunitz/xz"
    "golang.org/x/xerrors"
    "io"
    "io/ioutil"
    "net/http"
    "os"
    "path/filepath"
    "reflect"
    "unsafe"
)

/*
    /✱
    int function(int);

    #define DEFINE_JUMPER(x) \
         void *_godl_##x = (void*)0; \
         __asm__(".global "#x"\n\t"#x":\n\tmovq _godl_"#x"(%rip),%rax\n\tjmp *%rax\n")

    DEFINE_JUMPER(function)
    ✱/
    import "C"

    import (
        "github.com/sudachen/go-dl/dl"
        "runtime"
        "unsafe"
    )

    func init() {
        if runtime.GOOS == "linux" && runtime.GOARCH == "amd64"{
            so := dl.Load(
                dl.Cache("dl/go-dl/libfunction.so"),
                dl.LzmaExternal("https://github.com/sudachen/go-dl/releases/download/initial/libfunction_lin64.lzma"))
        } else if runtime.GOOS == "windows" && runtime.GOARCH == "amd64" {
            so := dl.Load(
                dl.Cache("dl/go-dl/function.dll"),
                dl.LzmaExternal("https://github.com/sudachen/go-dl/releases/download/initial/libfunction_win64.lzma"))
        }
        so.Bind("function",unsafe.Pointer(&C._godl_function))
    }

    func main() {
        C.function(0)
    }
*/

/*
Load finds and loads shared library. Can download library form the Internet if it's required
*/
func Load(a ...interface{}) SO {
    so := SO{
        verbose: IfsOption(Verbose(func(text string, vl int) {
            if vl == 0 {
                fmt.Println(text)
            }
        }), a).(Verbose),
        onerror: IfsOption(OnError(func(err error) {
            panic(err.Error())
        }), a).(OnError),
    }

    cached := ""

    for _, x := range a {
        switch q := x.(type) {
        case System, Custom:
            s := reflect.ValueOf(q).String()
            so.verbose(fmt.Sprintf("trying to load `%v`", s), 2)
            so.dlHandle, _ = loadLibrary(s)
            if so.dlHandle != 0 {
                return so
            }
        case Cached:
            cached = expandCache(reflect.ValueOf(q).String())
            so.verbose(fmt.Sprintf("trying to load `%v`", cached), 2)
            so.dlHandle, _ = loadLibrary(cached)
            if so.dlHandle != 0 {
                return so
            }
        }
    }

    if cached != "" {
        if preload(cached, a...) {
            so.verbose(fmt.Sprintf("trying to load `%v`", cached), 2)
            so.dlHandle, _ = loadLibrary(cached)
            if so.dlHandle != 0 {
                return so
            }
        }
    }

    so.onerror(xerrors.Errorf("not found or failed to load dynamic library"))
    return SO{}
}

/*
Bind binds the pointer to the shared library function
*/
func (so SO) Bind(funcname string, ptrptr unsafe.Pointer) {
    if !so.Ok() {
        so.onerror(xerrors.Errorf("dynamic library object is not initialized"))
        return
    }
    so.verbose(fmt.Sprintf("binding SO.'%v' to *(%v)", funcname, ptrptr), 2)
    if err := bindFunction(so.dlHandle, funcname, ptrptr); err != nil {
        so.onerror(err)
    }
}

/*
Ok returns true if SO object is associated with a shared library
*/
func (so SO) Ok() bool {
    return so.dlHandle != 0
}

/*
SO object incapacitates shared library handle
*/
type SO struct {
    dlHandle uintptr
    verbose  Verbose
    onerror  OnError
}

/*
LzmaExternal specifies url to the LZMA2 compressed shared library
*/
type LzmaExternal string

/*
GzipExternal specifies url to the Gzip compressed shared library
*/
type GzipExternal string

/*
External specifies url to the uncompressed shared library
*/
type External string

/*
Verbose defines function to print information messages
*/
type Verbose func(string, int)

/*
OnError defines function for error processing
*/
type OnError func(error)

/*
Cached specifies cache file and enables loading file from the Internet
*/
type Cached string

/*
System specifies system shared dll
*/
type System string

/*
Custom specifies full path to load specific shared library
*/
type Custom string

/*
Preload loads shared library from the Internet
*/
func (c Custom) Preload(a ...interface{}) {
    preload(string(c), a...)
}

/*
Preload loads shared library from the Internet
*/
func (c Cached) Preload(a ...interface{}) {
    preload(expandCache(string(c)), a...)
}

func preload(sopath string, a ...interface{}) (ok bool) {
    verbose := IfsOption(Verbose(func(text string, vl int) {
        if vl == 0 {
            fmt.Println(text)
        }
    }), a).(Verbose)
    onerror := IfsOption(OnError(func(err error) {
        panic(err.Error())
    }), a).(OnError)

    external, zt := StrMultiOption(a, External(""), GzipExternal(""), LzmaExternal(""))
    if external != "" {

        bf := bytes.Buffer{}

        verbose(fmt.Sprintf("downloading `%v`", external), 1)
        if resp, err := http.Get(external); err == nil {
            defer resp.Body.Close()
            if _, err = io.Copy(&bf, resp.Body); err == nil {
                if zt > 0 { // compressed
                    bx := bf
                    bf = bytes.Buffer{}
                    switch zt {
                    case 1: // GzipExternal
                        verbose("unpacking gzip", 2)
                        var z io.ReadCloser
                        if z, err = gzip.NewReader(&bx); err == nil {
                            defer z.Close()
                            _, err = io.Copy(&bf, z)
                        }
                    case 2: // LzmaExternal
                        verbose("unpacking lzma", 2)
                        var z io.Reader
                        if z, err = xz.NewReader(&bx); err == nil {
                            _, err = io.Copy(&bf, z)
                        }
                        //default:
                        //    panic("unknown compression")
                    }
                }
                if err == nil {
                    verbose(fmt.Sprintf("caching as `%v`", sopath), 2)
                    _ = os.MkdirAll(filepath.Dir(sopath), 0755)
                    err = ioutil.WriteFile(sopath, bf.Bytes(), 0644)
                }
            }
            if err != nil {
                onerror(err)
                return
            }
        }
        ok = true
    }
    return
}

/*
Remove removes cached file
*/
func (c Cached) Remove() (err error) {
    s := expandCache(string(c))
    _, err = os.Stat(s)
    if err == nil {
        return os.Remove(s)
    }
    return nil
}