ExternalVendorCode/balena-supervisor
1
0
Fork 0
mirror of https://github.com/balena-os/balena-supervisor.git synced 2025-05-31 06:41:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Auto-merge for PR #482 via VersionBot

Browse Source 
Multicontainer
This commit is contained in:
resin-io-versionbot[bot] 2018-03-07 13:37:25 +00:00 committed by GitHub
commit a60f1a1077
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
350 changed files with 6419 additions and 41264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.dockerignore
View File

@ -5,3 +5,4 @@ node_modules
tools
dindctl
README.md
knexfile.js

14
CHANGELOG.md
View File

@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file
automatically by Versionist. DO NOT EDIT THIS FILE MANUALLY!
This project adheres to [Semantic Versioning](http://semver.org/).
## v7.0.0 - 2018-03-07
* Send logs to the resin API by default #482 [Pablo Carranza Velez]
* Implement a new logger that sends logs to the resin API, that can be used optionally instead of PubNub #482 [Pablo Carranza Velez]
* Fix the way commands and entrypoints in string form are parsed #482 [Pablo Carranza Velez]
* Use a supervisor0 network interface for the supervisor network API. Remove RESIN_APP_COMMIT and RESIN_APP_RELEASE env vars. #482 [Pablo Carranza Velez]
* Supervisor API: remove the tcp-ping endpoints #482 [Pablo Carranza Velez]
* Remove support for keeping the provisioning apiKey on Resin OS 1.X. Report initial values from config.txt and other device configuration variables to the Resin API. #482 [Pablo Carranza Velez]
* Remove all bind mounts that were specific to 1.X devices. Move the resin-kill-me file for the handover strategy to /tmp/resin. Add environment variables for the location of resin-kill-me and the lockfile. Use running containers to determine what services are running instead of storing them in the internal database. Use named volumes for persistent data. #482 [Pablo Carranza Velez]
* Allow running docker-compose-like multicontainer applications #482 [Pablo Carranza Velez]
* Implement inference of device configuration. Allow array values for dtoverlay and dtparam. #482 [Pablo Carranza Velez]
* Infer the current state of the device when applying the target state #482 [Pablo Carranza Velez]
* Implement the multicontainer app models, and change the supervisor configuration management to avoid duplication between fields in config.json and fields in the internal database #482 [Pablo Carranza Velez]
## v6.6.9 - 2018-03-05
* Update update-locking.md #565 [zwalchuk]

2
Dockerfile
View File

@ -138,7 +138,7 @@ COPY package.json /usr/src/app/
RUN JOBS=MAX npm install --no-optional --unsafe-perm
COPY webpack.config.js fix-jsonstream.js /usr/src/app/
COPY webpack.config.js fix-jsonstream.js hardcode-migrations.js /usr/src/app/
COPY src /usr/src/app/src
RUN npm run lint \

21
gosuper/glide.lock generated
View File

@ -6,31 +6,10 @@ imports:
subpackages:
- dbus
- login1
- name: github.com/docker/go-units
version: 0dadbb0345b35ec7ef35e228dabb8de89a65bf52
- name: github.com/go-ole/go-ole
version: 02d3668a0cf01f58411cc85cd37c174c257ec7c2
subpackages:
- oleutil
- name: github.com/godbus/dbus
version: 012f3c27dcbdbe5d1285634e604e4ef869d83f7d
- name: github.com/gorilla/context
version: 08b5f424b9271eedf6f9f0ce86cb9396ed337a42
- name: github.com/gorilla/mux
version: bcd8bc72b08df0f70df986b97f95590779502d31
- name: github.com/samalba/dockerclient
version: a3036261847103270e9f732509f43b5f98710ace
- name: github.com/shirou/gopsutil
version: e30b7839cd6161b2fbef5f187377a345157abe04
subpackages:
- cpu
- host
- internal/common
- mem
- net
- process
- name: github.com/shirou/w32
version: bb4de0191aa41b5507caa14b0650cdbddcd9280b
- name: github.com/StackExchange/wmi
version: ea383cf3ba6ec950874b8486cd72356d007c768f
testImports: []

5
gosuper/glide.yaml
View File

@ -7,8 +7,3 @@ import:
- login1
- package: github.com/gorilla/mux
version: ^1.4.0
- package: github.com/samalba/dockerclient
- package: github.com/shirou/gopsutil
version: ^2.17.5
subpackages:
- process

192
gosuper/gosuper/api.go
View File

@ -4,31 +4,18 @@ import (
"encoding/json"
"fmt"
"log"
"net"
"net/http"
"os"
"regexp"
"strconv"
"time"
"resin-supervisor/gosuper/systemd"
)
// Compile the expression once, usually at init time.
// Use raw strings to avoid having to quote the backslashes.
var dockerMatch = regexp.MustCompile(`(balena[0-9]+)|(docker[0-9]+)|(rce[0-9]+)|(tun[0-9]+)|(resin-vpn)|(resin-dns)`)
// APIResponse The api response sent from go supervisor
type APIResponse struct {
Data interface{}
Error string
}
//PurgeBody struct for the ApplicationId interfact
type PurgeBody struct {
ApplicationId interface{}
}
// VPNBody interface for post request received by VPN control end point
type VPNBody struct {
Enable bool
@ -57,24 +44,6 @@ func parseJSONBody(destination interface{}, request *http.Request) error {
return decoder.Decode(&destination)
}
func parsePurgeBody(request *http.Request) (appId string, err error) {
var body PurgeBody
if err = parseJSONBody(&body, request); err != nil {
return
}
switch v := body.ApplicationId.(type) {
case string:
appId = v
case float64:
if v != 0 {
appId = strconv.Itoa(int(v))
}
default:
log.Printf("Invalid appId type %T\n", v)
}
return
}
func responseSenders(writer http.ResponseWriter) (sendResponse func(interface{}, string, int), sendError func(error)) {
sendResponse = func(data interface{}, errorMsg string, statusCode int) {
jsonResponse(writer, APIResponse{data, errorMsg}, statusCode)
@ -85,35 +54,6 @@ func responseSenders(writer http.ResponseWriter) (sendResponse func(interface{},
return
}
// PurgeHandler Purges the data of the appID's application in the /data partition
func PurgeHandler(writer http.ResponseWriter, request *http.Request) {
log.Println("Purging /data")
sendResponse, sendError := responseSenders(writer)
sendBadRequest := func(errorMsg string) {
sendResponse("Error", errorMsg, http.StatusBadRequest)
}
if appId, err := parsePurgeBody(request); err != nil {
sendBadRequest("Invalid request")
} else if appId == "" {
sendBadRequest("applicationId is required")
} else if !IsValidAppId(appId) {
sendBadRequest(fmt.Sprintf("Invalid applicationId '%s'", appId))
} else if _, err = os.Stat(ResinDataPath + appId); err != nil {
if os.IsNotExist(err) {
sendResponse("Error", fmt.Sprintf("Invalid applicationId '%s': Directory does not exist", appId), http.StatusNotFound)
} else {
sendError(err)
}
} else if err = os.RemoveAll(ResinDataPath + appId); err != nil {
sendError(err)
} else if err = os.Mkdir(ResinDataPath+appId, 0755); err != nil {
sendError(err)
} else {
sendResponse("OK", "", http.StatusOK)
}
}
func inASecond(theFunc func()) {
time.Sleep(time.Duration(time.Second))
theFunc()
@ -145,55 +85,6 @@ func ShutdownHandler(writer http.ResponseWriter, request *http.Request) {
go inASecond(func() { systemd.Logind.PowerOff(false) })
}
// This function returns all active IPs of the interfaces that arent docker/rce and loopback
func ipAddress() (ipAddresses []string, err error) {
ifaces, err := net.Interfaces()
if err != nil {
return ipAddresses, err
}
for _, iface := range ifaces {
if (iface.Flags&net.FlagUp == 0) || (iface.Flags&net.FlagLoopback != 0) || dockerMatch.MatchString(iface.Name) {
continue // Interface down or Interface is loopback or Interface is a docker IP
}
addrs, err := iface.Addrs()
if err != nil {
return ipAddresses, err
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
default:
log.Printf("Warning: Unrecognised type %T\n", v)
continue
}
if ip == nil {
continue
}
if ip = ip.To4(); ip == nil {
continue // This isnt an IPv4 Addresss
}
ipAddresses = append(ipAddresses, ip.String())
}
}
return
}
//IPAddressHandler is used to reply back with an array of the IPaddress used by the system.
func IPAddressHandler(writer http.ResponseWriter, request *http.Request) {
sendResponse, sendError := responseSenders(writer)
if ipAddr, err := ipAddress(); err != nil {
sendError(err)
} else {
payload := make(map[string][]string)
payload["IPAddresses"] = ipAddr
sendResponse(payload, "", http.StatusOK)
}
}
//VPNControl is used to control VPN service status with dbus
func VPNControl(writer http.ResponseWriter, request *http.Request) {
sendResponse, sendError := responseSenders(writer)
@ -224,11 +115,75 @@ func VPNControl(writer http.ResponseWriter, request *http.Request) {
sendResponse("OK", "", http.StatusAccepted)
}
func getUnitStatus(unitName string) (state bool, err error) {
if systemd.Dbus == nil {
err = fmt.Errorf("Systemd dbus unavailable, cannot get unit status.")
return
}
if activeState, e := systemd.Dbus.GetUnitProperty(unitName, "ActiveState"); e != nil {
err = fmt.Errorf("Unable to get unit status: %v", e)
return
} else {
state = activeState.Value.String() == `"active"`
return
}
}
func unitStatusHandler(serviceName string, writer http.ResponseWriter, request *http.Request) {
sendResponse, sendError := responseSenders(writer)
if status, err := getUnitStatus(serviceName); err != nil {
sendError(fmt.Errorf("Unable to get VPN status: %v", err))
} else {
sendResponse(status, "", http.StatusOK)
}
}
func VPNStatus(writer http.ResponseWriter, request *http.Request) {
unitStatusHandler("openvpn-resin.service", writer, request)
}
func logToDisplayServiceName() (serviceName string, err error) {
serviceName = "resin-info@tty1.service"
serviceNameOld := "tty-replacement.service"
if systemd.Dbus == nil {
err = fmt.Errorf("Systemd dbus unavailable, cannot get log to display service.")
return
}
if loaded, e := systemd.Dbus.GetUnitProperty(serviceName, "LoadState"); e != nil {
err = fmt.Errorf("Unable to get log to display load status: %v", e)
return
} else if loaded.Value.String() == `"not-found"` {
// If the resin-info service is not found, we're on an older OS
// which uses a different service name
serviceName = serviceNameOld
}
if loaded, e := systemd.Dbus.GetUnitProperty(serviceName, "LoadState"); e != nil {
err = fmt.Errorf("Unable to get log to display load status: %v", e)
return
} else if loaded.Value.String() == `"not-found"` {
// We might be in a different OS that just doesn't have the service
serviceName = ""
return
}
return
}
func LogToDisplayStatus(writer http.ResponseWriter, request *http.Request) {
sendResponse, sendError := responseSenders(writer)
serviceName, err := logToDisplayServiceName()
if err != nil {
sendError(err)
return
} else if serviceName == "" {
sendResponse("Error", "Not found", http.StatusNotFound)
return
}
unitStatusHandler(serviceName, writer, request)
}
//LogToDisplayControl is used to control tty-replacement service status with dbus
func LogToDisplayControl(writer http.ResponseWriter, request *http.Request) {
sendResponse, sendError := responseSenders(writer)
serviceName := "resin-info@tty1.service"
serviceNameOld := "tty-replacement.service"
var body LogToDisplayBody
if err := parseJSONBody(&body, request); err != nil {
log.Println(err)
@ -241,20 +196,19 @@ func LogToDisplayControl(writer http.ResponseWriter, request *http.Request) {
return
}
if loaded, err := systemd.Dbus.GetUnitProperty(serviceName, "LoadState"); err != nil {
sendError(fmt.Errorf("Unable to get log to display load status: %v", err))
serviceName, err := logToDisplayServiceName()
if err != nil {
sendError(err)
return
} else if serviceName == "" {
sendResponse("Error", "Not found", http.StatusNotFound)
return
} else if loaded.Value.String() == `"not-found"` {
// If the resin-info service is not found, we're on an older OS
// which uses a different service name
serviceName = serviceNameOld
}
if activeState, err := systemd.Dbus.GetUnitProperty(serviceName, "ActiveState"); err != nil {
if status, err := getUnitStatus(serviceName); err != nil {
sendError(fmt.Errorf("Unable to get log to display status: %v", err))
return
} else {
status := activeState.Value.String() == `"active"`
enable := body.Enable
if status == enable {
// Nothing to do, return Data = false to signal nothing was changed

25
gosuper/gosuper/config.go
View File

@ -1,25 +0,0 @@
package main
import (
"encoding/json"
"io/ioutil"
)
type UserConfig struct {
ApplicationId string
ApiKey string
UserId string
Username string
DeviceType string
Uuid string
RegisteredAt float64
DeviceId float64
}
func ReadConfig(path string) (config UserConfig, err error) {
if data, err := ioutil.ReadFile(path); err == nil {
err = json.Unmarshal(data, &config)
}
return
}

1
gosuper/gosuper/config_for_test.json
View File

@ -1 +0,0 @@
{"applicationId":"1939","apiKey":"SuperSecretAPIKey","userId":"141","username":"gh_pcarranzav","deviceType":"raspberry-pi2","files":{"network/settings":"[global]\nOfflineMode=false\n\n[WiFi]\nEnable=true\nTethering=false\n\n[Wired]\nEnable=true\nTethering=false\n\n[Bluetooth]\nEnable=true\nTethering=false","network/network.config":"[service_home_ethernet]\nType = ethernet\nNameservers = 8.8.8.8,8.8.4.4"},"uuid":"07cf830a18757a78e69293ef2daf315506074a59f694555c124f0151e67f8d","registered_at":1436987572906,"deviceId":24748}

40
gosuper/gosuper/main.go
View File

@ -6,26 +6,22 @@ import (
"net"
"net/http"
"os"
"time"
"github.com/gorilla/mux"
"resin-supervisor/gosuper/psutils"
)
var ResinDataPath string = "/mnt/root/resin-data/"
func setupApi(router *mux.Router) {
router.HandleFunc("/ping", func(writer http.ResponseWriter, request *http.Request) {
fmt.Fprintln(writer, "OK")
})
apiv1 := router.PathPrefix("/v1").Subrouter()
apiv1.HandleFunc("/ipaddr", IPAddressHandler).Methods("GET")
apiv1.HandleFunc("/purge", PurgeHandler).Methods("POST")
apiv1.HandleFunc("/reboot", RebootHandler).Methods("POST")
apiv1.HandleFunc("/shutdown", ShutdownHandler).Methods("POST")
apiv1.HandleFunc("/vpncontrol", VPNControl).Methods("POST")
apiv1.HandleFunc("/set-log-to-display", LogToDisplayControl).Methods("POST")
apiv1.HandleFunc("/vpncontrol", VPNStatus).Methods("GET")
apiv1.HandleFunc("/log-to-display", LogToDisplayControl).Methods("POST")
apiv1.HandleFunc("/log-to-display", LogToDisplayStatus).Methods("GET")
apiv1.HandleFunc("/restart-service", RestartService).Methods("POST")
}
@ -40,39 +36,9 @@ func startApi(listenAddress string, router *mux.Router) {
}
}
func startOOMProtectionTimer(hostproc string, dockerSocket string) *time.Ticker {
ticker := time.NewTicker(time.Minute * 5) //Timer runs every 5 minutes
procs := &psutils.Procs{hostproc}
log.Println("Changing oom_score_adj for the supervisor container to -800")
if err := procs.AdjustDockerOOMPriority("unix://"+dockerSocket, "resin_supervisor", -800, false); err != nil {
log.Printf("FAILED to OOM protect supervisor container: %s\n", err)
}
// Code below this could be eventually deprecated after all the devices are > 5 Jan 2016 deployment as this will be handled in the HOST OS.
log.Println("Changing oom_score_adj for openvpn and connmand to -1000 if 0, every 5 minutes")
// Errors are not being caught here as users could have openvpn and connmand disabled.
procs.AdjustOOMPriorityByName("openvpn", -1000, true)
procs.AdjustOOMPriorityByName("connmand", -1000, true)
go func() {
for _ = range ticker.C {
procs.AdjustOOMPriorityByName("openvpn", -1000, true)
procs.AdjustOOMPriorityByName("connmand", -1000, true)
}
}()
return ticker
}
func main() {
log.SetFlags(log.Lshortfile | log.LstdFlags)
log.Println("Resin Go Supervisor starting")
// Start OOMProtectionTimer for protecting Openvpn/Connman
dockerSocket := os.Getenv("DOCKER_SOCKET")
hostproc := os.Getenv("HOST_PROC")
if dataPathEnv := os.Getenv("RESIN_DATA_PATH"); dataPathEnv != "" {
ResinDataPath = "/mnt/root" + dataPathEnv
}
defer startOOMProtectionTimer(hostproc, dockerSocket).Stop()
listenAddress := os.Getenv("GOSUPER_SOCKET")
router := mux.NewRouter()
setupApi(router)

73
gosuper/gosuper/main_test.go
View File

@ -1,73 +0,0 @@
package main
import (
"io/ioutil"
"net/http"
"net/http/httptest"
"os"
"strings"
"testing"
)
var purgeTests = []struct {
JsonInput string
AppId string
JsonResponse string
IsSuccess bool
HttpStatus int
}{
{`{"applicationId": "1"}`, "1", `{"Data":"OK","Error":""}`, true, http.StatusOK},
{`{"applicationId": 1}`, "1", `{"Data":"OK","Error":""}`, true, http.StatusOK},
{`{"applicationId": "hi"}`, "1", `{"Data":"Error","Error":"Invalid applicationId 'hi'"}`, false, http.StatusBadRequest},
{`{"applicationId": "2"}`, "1", `{"Data":"Error","Error":"Invalid applicationId '2': Directory does not exist"}`, false, http.StatusNotFound},
{`{}`, "1", `{"Data":"Error","Error":"applicationId is required"}`, false, http.StatusBadRequest},
}
func TestPurge(t *testing.T) {
for i, testCase := range purgeTests {
t.Logf("Testing Purge case #%d", i)
request, err := http.NewRequest("POST", "/v1/purge", strings.NewReader(testCase.JsonInput))
if err != nil {
t.Fatal(err)
}
request.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
writer := httptest.NewRecorder()
ResinDataPath = "test-data/"
dataPath := ResinDataPath + testCase.AppId
testFile := dataPath + "/test"
if err = os.MkdirAll(dataPath, 0755); err != nil {
t.Fatal("Could not create test directory for purge")
} else if err = ioutil.WriteFile(testFile, []byte("test"), 0777); err != nil {
t.Fatal("Could not create test file for purge")
}
PurgeHandler(writer, request)
if writer.Code != testCase.HttpStatus {
t.Errorf("Purge didn't return %v, got %v", testCase.HttpStatus, writer.Code)
}
if !strings.EqualFold(writer.Body.String(), testCase.JsonResponse) {
t.Errorf(`Purge response didn't match the expected JSON, expected "%s" got: "%s"`, testCase.JsonResponse, writer.Body.String())
}
if dirContents, err := ioutil.ReadDir(dataPath); err != nil {
t.Errorf("Could not read the data path after purge: %s", err)
} else {
fileCount := len(dirContents)
if fileCount > 0 && testCase.IsSuccess {
t.Error("Data directory not empty after purge")
} else if fileCount == 0 && !testCase.IsSuccess {
t.Error("Data directory empty after purge (but it failed)")
}
}
}
}
func TestReadConfig(t *testing.T) {
if config, err := ReadConfig("config_for_test.json"); err != nil {
t.Error(err)
} else if !strings.EqualFold(config.ApplicationId, "1939") || !strings.EqualFold(config.ApiKey, "SuperSecretAPIKey") {
t.Error("Config not parsed correctly")
}
}

11
gosuper/gosuper/validation.go
View File

@ -1,11 +0,0 @@
package main
import (
"strconv"
)
func IsValidAppId(appId string) (valid bool) {
_, err := strconv.ParseUint(appId, 10, 0)
valid = err == nil
return
}

82
gosuper/psutils/psutils.go
View File

@ -1,82 +0,0 @@
package psutils
import (
"fmt"
"io/ioutil"
"log"
"path"
"strconv"
"strings"
"github.com/samalba/dockerclient"
"github.com/shirou/gopsutil/process"
)
// Procs - psutils functions associated with the ProcfsPath
type Procs struct {
ProcfsPath string
}
// parseInt - Parse integer from string.
func parseInt(str string) (int, error) {
// strconv chokes on whitespace, go figure.
trimmed := strings.TrimSpace(str)
return strconv.Atoi(trimmed)
}
//AdjustOOMPriorityByName Adjust the OOM adj value for the process' with the given name regexp
func (procs *Procs) AdjustOOMPriorityByName(processName string, value int, ignoreIfNonZero bool) error {
found := false
pids, err := process.Pids()
if err != nil {
return err
}
for _, pid := range pids {
// Find the process with the given name
if currProcess, err := process.NewProcess(pid); err != nil {
continue
} else if name, err := currProcess.Name(); err != nil || name != processName {
continue
} else if err := procs.AdjustOOMPriority(int(pid), value, ignoreIfNonZero); err == nil {
found = true
} else {
// Not an error but logging these for debugging.
log.Printf("Error adjusting OOM for process %s (pid %d): %s", processName, pid, err)
}
}
if found {
return nil
}
return fmt.Errorf("No process matches: %s\n", processName)
}
//AdjustOOMPriority Adjust the OOM adj value for the process with the given pid.
func (procs *Procs) AdjustOOMPriority(pid int, value int, ignoreIfNonZero bool) error {
valueBytes := []byte(strconv.Itoa(value))
oomFile := fmt.Sprintf("%s/%d/oom_score_adj", path.Clean(procs.ProcfsPath), pid)
if currentOOMBytes, err := ioutil.ReadFile(oomFile); err != nil {
return err
} else if currentOOMValue, err := parseInt(string(currentOOMBytes)); err != nil {
return fmt.Errorf("Unable to read OOM adjust for pid: %d\n", pid)
} else if ignoreIfNonZero && currentOOMValue != 0 {
return nil
} else if err = ioutil.WriteFile(oomFile, valueBytes, 0644); err != nil {
return fmt.Errorf("Unable to OOM adjust for pid: %d\n", pid)
}
return nil
}
//AdjustDockerOOMPriority Adjusts the OOM Adj value for the entire docker container specified by the name. This should point to root proc filesystem
func (procs *Procs) AdjustDockerOOMPriority(connection string, containerName string, value int, ignoreIfNonZero bool) error {
if docker, err := dockerclient.NewDockerClient(connection, nil); err != nil {
return err
} else if containers, err := docker.ListContainers(false, false, fmt.Sprintf(`{"name":["^/%s$"]}`, containerName)); err != nil {
return err
} else if containerInfo, err := docker.InspectContainer(containers[0].Id); err != nil {
return err
} else if err := procs.AdjustOOMPriority(containerInfo.State.Pid, value, ignoreIfNonZero); err != nil {
return err
} else {
return nil
}
}

75
gosuper/supertest/super_test.go
View File

@ -1,75 +0,0 @@
package supertest
import (
"io/ioutil"
"log"
"net/http"
"os"
"strings"
"testing"
gosuper "resin-supervisor/gosuper/gosuper"
)
var supervisorAddress string
var config gosuper.UserConfig
func TestMain(m *testing.M) {
var err error
if gopath := os.Getenv("GOPATH"); gopath == "" {
log.Fatal("GOPATH is not set - where are you running this?")
} else if supervisorIP := os.Getenv("SUPERVISOR_IP"); supervisorIP == "" {
log.Fatal("Supervisor IP not set - is it running?")
} else if config, err = gosuper.ReadConfig(gopath + "/src/resin-supervisor/gosuper/config.json"); err != nil {
log.Fatal(err)
} else {
supervisorAddress = "http://" + supervisorIP + ":48484"
os.Exit(m.Run())
}
}
func TestPing(t *testing.T) {
if request, err := http.NewRequest("GET", supervisorAddress+"/ping?apikey=bananas", nil); err != nil {
t.Fatal(err)
} else if response, err := http.DefaultClient.Do(request); err != nil {
t.Fatal(err)
} else if response.StatusCode != http.StatusOK {
t.Fatalf("Expected 200, got %d", response.StatusCode)
}
}
func TestPurge(t *testing.T) {
appId := config.ApplicationId
dataPath := "/resin-data/" + appId
if err := ioutil.WriteFile(dataPath+"/test", []byte("test"), 0777); err != nil {
t.Fatal("Could not create test file for purge")
} else if request, err := http.NewRequest("POST", supervisorAddress+"/v1/purge?apikey=bananas", strings.NewReader(`{"appId": "`+appId+`"}`)); err != nil {
t.Fatal(err)
} else {
request.Header.Set("Content-Type", "application/json")
response, err := http.DefaultClient.Do(request)
defer response.Body.Close()
if err != nil {
t.Fatal(err)
} else if response.StatusCode != http.StatusOK {
t.Errorf("Expected 200, got %d", response.StatusCode)
if contents, err := ioutil.ReadAll(response.Body); err != nil {
t.Fatal(err)
} else {
t.Fatalf("Response: %s", contents)
}
} else {
if contents, err := ioutil.ReadAll(response.Body); err != nil {
t.Fatal(err)
} else if !strings.EqualFold(string(contents), `{"Data":"OK","Error":""}`) {
t.Errorf("Purge response didn't match the expected JSON, got: %s", contents)
}
if dirContents, err := ioutil.ReadDir(dataPath); err != nil {
t.Errorf("Could not read the data path after purge: %s", err)
} else if len(dirContents) > 0 {
t.Error("Data directory not empty after purge")
}
}
}
}

3
gosuper/vendor/.gitattributes vendored
View File

@ -1,3 +0,0 @@
# Ignore all vendor diffs
* -diff

20
gosuper/vendor/github.com/StackExchange/wmi/LICENSE generated vendored
View File

@ -1,20 +0,0 @@
The MIT License (MIT)
Copyright (c) 2013 Stack Exchange
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

6
gosuper/vendor/github.com/StackExchange/wmi/README.md generated vendored
View File

@ -1,6 +0,0 @@
wmi
===
Package wmi provides a WQL interface to Windows WMI.
Note: It interfaces with WMI on the local machine, therefore it only runs on Windows.

260
gosuper/vendor/github.com/StackExchange/wmi/swbemservices.go generated vendored
View File

@ -1,260 +0,0 @@
// +build windows
package wmi
import (
"fmt"
"reflect"
"runtime"
"sync"
"github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
// SWbemServices is used to access wmi. See https://msdn.microsoft.com/en-us/library/aa393719(v=vs.85).aspx
type SWbemServices struct {
//TODO: track namespace. Not sure if we can re connect to a different namespace using the same instance
cWMIClient *Client //This could also be an embedded struct, but then we would need to branch on Client vs SWbemServices in the Query method
sWbemLocatorIUnknown *ole.IUnknown
sWbemLocatorIDispatch *ole.IDispatch
queries chan *queryRequest
closeError chan error
lQueryorClose sync.Mutex
}
type queryRequest struct {
query string
dst interface{}
args []interface{}
finished chan error
}
// InitializeSWbemServices will return a new SWbemServices object that can be used to query WMI
func InitializeSWbemServices(c *Client, connectServerArgs ...interface{}) (*SWbemServices, error) {
//fmt.Println("InitializeSWbemServices: Starting")
//TODO: implement connectServerArgs as optional argument for init with connectServer call
s := new(SWbemServices)
s.cWMIClient = c
s.queries = make(chan *queryRequest)
initError := make(chan error)
go s.process(initError)
err, ok := <-initError
if ok {
return nil, err //Send error to caller
}
//fmt.Println("InitializeSWbemServices: Finished")
return s, nil
}
// Close will clear and release all of the SWbemServices resources
func (s *SWbemServices) Close() error {
s.lQueryorClose.Lock()
if s == nil || s.sWbemLocatorIDispatch == nil {
s.lQueryorClose.Unlock()
return fmt.Errorf("SWbemServices is not Initialized")
}
if s.queries == nil {
s.lQueryorClose.Unlock()
return fmt.Errorf("SWbemServices has been closed")
}
//fmt.Println("Close: sending close request")
var result error
ce := make(chan error)
s.closeError = ce //Race condition if multiple callers to close. May need to lock here
close(s.queries) //Tell background to shut things down
s.lQueryorClose.Unlock()
err, ok := <-ce
if ok {
result = err
}
//fmt.Println("Close: finished")
return result
}
func (s *SWbemServices) process(initError chan error) {
//fmt.Println("process: starting background thread initialization")
//All OLE/WMI calls must happen on the same initialized thead, so lock this goroutine
runtime.LockOSThread()
defer runtime.LockOSThread()
err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
if err != nil {
oleCode := err.(*ole.OleError).Code()
if oleCode != ole.S_OK && oleCode != S_FALSE {
initError <- fmt.Errorf("ole.CoInitializeEx error: %v", err)
return
}
}
defer ole.CoUninitialize()
unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator")
if err != nil {
initError <- fmt.Errorf("CreateObject SWbemLocator error: %v", err)
return
} else if unknown == nil {
initError <- ErrNilCreateObject
return
}
defer unknown.Release()
s.sWbemLocatorIUnknown = unknown
dispatch, err := s.sWbemLocatorIUnknown.QueryInterface(ole.IID_IDispatch)
if err != nil {
initError <- fmt.Errorf("SWbemLocator QueryInterface error: %v", err)
return
}
defer dispatch.Release()
s.sWbemLocatorIDispatch = dispatch
// we can't do the ConnectServer call outside the loop unless we find a way to track and re-init the connectServerArgs
//fmt.Println("process: initialized. closing initError")
close(initError)
//fmt.Println("process: waiting for queries")
for q := range s.queries {
//fmt.Printf("process: new query: len(query)=%d\n", len(q.query))
errQuery := s.queryBackground(q)
//fmt.Println("process: s.queryBackground finished")
if errQuery != nil {
q.finished <- errQuery
}
close(q.finished)
}
//fmt.Println("process: queries channel closed")
s.queries = nil //set channel to nil so we know it is closed
//TODO: I think the Release/Clear calls can panic if things are in a bad state.
//TODO: May need to recover from panics and send error to method caller instead.
close(s.closeError)
}
// Query runs the WQL query using a SWbemServices instance and appends the values to dst.
//
// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
// the query must have the same name in dst. Supported types are all signed and
// unsigned integers, time.Time, string, bool, or a pointer to one of those.
// Array types are not supported.
//
// By default, the local machine and default namespace are used. These can be
// changed using connectServerArgs. See
// http://msdn.microsoft.com/en-us/library/aa393720.aspx for details.
func (s *SWbemServices) Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
s.lQueryorClose.Lock()
if s == nil || s.sWbemLocatorIDispatch == nil {
s.lQueryorClose.Unlock()
return fmt.Errorf("SWbemServices is not Initialized")
}
if s.queries == nil {
s.lQueryorClose.Unlock()
return fmt.Errorf("SWbemServices has been closed")
}
//fmt.Println("Query: Sending query request")
qr := queryRequest{
query: query,
dst: dst,
args: connectServerArgs,
finished: make(chan error),
}
s.queries <- &qr
s.lQueryorClose.Unlock()
err, ok := <-qr.finished
if ok {
//fmt.Println("Query: Finished with error")
return err //Send error to caller
}
//fmt.Println("Query: Finished")
return nil
}
func (s *SWbemServices) queryBackground(q *queryRequest) error {
if s == nil || s.sWbemLocatorIDispatch == nil {
return fmt.Errorf("SWbemServices is not Initialized")
}
wmi := s.sWbemLocatorIDispatch //Should just rename in the code, but this will help as we break things apart
//fmt.Println("queryBackground: Starting")
dv := reflect.ValueOf(q.dst)
if dv.Kind() != reflect.Ptr || dv.IsNil() {
return ErrInvalidEntityType
}
dv = dv.Elem()
mat, elemType := checkMultiArg(dv)
if mat == multiArgTypeInvalid {
return ErrInvalidEntityType
}
// service is a SWbemServices
serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer", q.args...)
if err != nil {
return err
}
service := serviceRaw.ToIDispatch()
defer serviceRaw.Clear()
// result is a SWBemObjectSet
resultRaw, err := oleutil.CallMethod(service, "ExecQuery", q.query)
if err != nil {
return err
}
result := resultRaw.ToIDispatch()
defer resultRaw.Clear()
count, err := oleInt64(result, "Count")
if err != nil {
return err
}
enumProperty, err := result.GetProperty("_NewEnum")
if err != nil {
return err
}
defer enumProperty.Clear()
enum, err := enumProperty.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
if err != nil {
return err
}
if enum == nil {
return fmt.Errorf("can't get IEnumVARIANT, enum is nil")
}
defer enum.Release()
// Initialize a slice with Count capacity
dv.Set(reflect.MakeSlice(dv.Type(), 0, int(count)))
var errFieldMismatch error
for itemRaw, length, err := enum.Next(1); length > 0; itemRaw, length, err = enum.Next(1) {
if err != nil {
return err
}
err := func() error {
// item is a SWbemObject, but really a Win32_Process
item := itemRaw.ToIDispatch()
defer item.Release()
ev := reflect.New(elemType)
if err = s.cWMIClient.loadEntity(ev.Interface(), item); err != nil {
if _, ok := err.(*ErrFieldMismatch); ok {
// We continue loading entities even in the face of field mismatch errors.
// If we encounter any other error, that other error is returned. Otherwise,
// an ErrFieldMismatch is returned.
errFieldMismatch = err
} else {
return err
}
}
if mat != multiArgTypeStructPtr {
ev = ev.Elem()
}
dv.Set(reflect.Append(dv, ev))
return nil
}()
if err != nil {
return err
}
}
//fmt.Println("queryBackground: Finished")
return errFieldMismatch
}

151
gosuper/vendor/github.com/StackExchange/wmi/swbemservices_test.go generated vendored
View File

@ -1,151 +0,0 @@
// +build windows
package wmi
import (
"fmt"
"runtime"
"testing"
"time"
)
func TestWbemQuery(t *testing.T) {
s, err := InitializeSWbemServices(DefaultClient)
if err != nil {
t.Fatalf("InitializeSWbemServices: %s", err)
}
var dst []Win32_Process
q := CreateQuery(&dst, "WHERE name='lsass.exe'")
errQuery := s.Query(q, &dst)
if errQuery != nil {
t.Fatalf("Query1: %s", errQuery)
}
count := len(dst)
if count < 1 {
t.Fatal("Query1: no results found for lsass.exe")
}
//fmt.Printf("dst[0].ProcessID=%d\n", dst[0].ProcessId)
q2 := CreateQuery(&dst, "WHERE name='svchost.exe'")
errQuery = s.Query(q2, &dst)
if errQuery != nil {
t.Fatalf("Query2: %s", errQuery)
}
count = len(dst)
if count < 1 {
t.Fatal("Query2: no results found for svchost.exe")
}
//for index, item := range dst {
// fmt.Printf("dst[%d].ProcessID=%d\n", index, item.ProcessId)
//}
errClose := s.Close()
if errClose != nil {
t.Fatalf("Close: %s", errClose)
}
}
func TestWbemQueryNamespace(t *testing.T) {
s, err := InitializeSWbemServices(DefaultClient)
if err != nil {
t.Fatalf("InitializeSWbemServices: %s", err)
}
var dst []MSFT_NetAdapter
q := CreateQuery(&dst, "")
errQuery := s.Query(q, &dst, nil, "root\\StandardCimv2")
if errQuery != nil {
t.Fatalf("Query: %s", errQuery)
}
count := len(dst)
if count < 1 {
t.Fatal("Query: no results found for MSFT_NetAdapter in root\\StandardCimv2")
}
errClose := s.Close()
if errClose != nil {
t.Fatalf("Close: %s", errClose)
}
}
// Run using: go test -run TestWbemMemory -timeout 60m
func TestWbemMemory(t *testing.T) {
s, err := InitializeSWbemServices(DefaultClient)
if err != nil {
t.Fatalf("InitializeSWbemServices: %s", err)
}
start := time.Now()
limit := 500000
fmt.Printf("Benchmark Iterations: %d (Memory should stabilize around 7MB after ~3000)\n", limit)
var privateMB, allocMB, allocTotalMB float64
for i := 0; i < limit; i++ {
privateMB, allocMB, allocTotalMB = WbemGetMemoryUsageMB(s)
if i%100 == 0 {
privateMB, allocMB, allocTotalMB = WbemGetMemoryUsageMB(s)
fmt.Printf("Time: %4ds Count: %5d Private Memory: %5.1fMB MemStats.Alloc: %4.1fMB MemStats.TotalAlloc: %5.1fMB\n", time.Now().Sub(start)/time.Second, i, privateMB, allocMB, allocTotalMB)
}
}
errClose := s.Close()
if errClose != nil {
t.Fatalf("Close: %s", err)
}
fmt.Printf("Final Time: %4ds Private Memory: %5.1fMB MemStats.Alloc: %4.1fMB MemStats.TotalAlloc: %5.1fMB\n", time.Now().Sub(start)/time.Second, privateMB, allocMB, allocTotalMB)
}
func WbemGetMemoryUsageMB(s *SWbemServices) (float64, float64, float64) {
runtime.ReadMemStats(&mMemoryUsageMB)
errGetMemoryUsageMB = s.Query(qGetMemoryUsageMB, &dstGetMemoryUsageMB)
if errGetMemoryUsageMB != nil {
fmt.Println("ERROR GetMemoryUsage", errGetMemoryUsageMB)
return 0, 0, 0
}
return float64(dstGetMemoryUsageMB[0].WorkingSetPrivate) / MB, float64(mMemoryUsageMB.Alloc) / MB, float64(mMemoryUsageMB.TotalAlloc) / MB
}
//Run all benchmarks (should run for at least 60s to get a stable number):
//go test -run=NONE -bench=Version -benchtime=120s
//Individual benchmarks:
//go test -run=NONE -bench=NewVersion -benchtime=120s
func BenchmarkNewVersion(b *testing.B) {
s, err := InitializeSWbemServices(DefaultClient)
if err != nil {
b.Fatalf("InitializeSWbemServices: %s", err)
}
var dst []Win32_OperatingSystem
q := CreateQuery(&dst, "")
for n := 0; n < b.N; n++ {
errQuery := s.Query(q, &dst)
if errQuery != nil {
b.Fatalf("Query%d: %s", n, errQuery)
}
count := len(dst)
if count < 1 {
b.Fatalf("Query%d: no results found for Win32_OperatingSystem", n)
}
}
errClose := s.Close()
if errClose != nil {
b.Fatalf("Close: %s", errClose)
}
}
//go test -run=NONE -bench=OldVersion -benchtime=120s
func BenchmarkOldVersion(b *testing.B) {
var dst []Win32_OperatingSystem
q := CreateQuery(&dst, "")
for n := 0; n < b.N; n++ {
errQuery := Query(q, &dst)
if errQuery != nil {
b.Fatalf("Query%d: %s", n, errQuery)
}
count := len(dst)
if count < 1 {
b.Fatalf("Query%d: no results found for Win32_OperatingSystem", n)
}
}
}
type MSFT_NetAdapter struct {
Name string
InterfaceIndex int
DriverDescription string
}

468
gosuper/vendor/github.com/StackExchange/wmi/wmi.go generated vendored
View File

@ -1,468 +0,0 @@
// +build windows
/*
Package wmi provides a WQL interface for WMI on Windows.
Example code to print names of running processes:
type Win32_Process struct {
Name string
}
func main() {
var dst []Win32_Process
q := wmi.CreateQuery(&dst, "")
err := wmi.Query(q, &dst)
if err != nil {
log.Fatal(err)
}
for i, v := range dst {
println(i, v.Name)
}
}
*/
package wmi
import (
"bytes"
"errors"
"fmt"
"log"
"os"
"reflect"
"runtime"
"strconv"
"strings"
"sync"
"time"
"github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
var l = log.New(os.Stdout, "", log.LstdFlags)
var (
ErrInvalidEntityType = errors.New("wmi: invalid entity type")
// ErrNilCreateObject is the error returned if CreateObject returns nil even
// if the error was nil.
ErrNilCreateObject = errors.New("wmi: create object returned nil")
lock sync.Mutex
)
// S_FALSE is returned by CoInitializeEx if it was already called on this thread.
const S_FALSE = 0x00000001
// QueryNamespace invokes Query with the given namespace on the local machine.
func QueryNamespace(query string, dst interface{}, namespace string) error {
return Query(query, dst, nil, namespace)
}
// Query runs the WQL query and appends the values to dst.
//
// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
// the query must have the same name in dst. Supported types are all signed and
// unsigned integers, time.Time, string, bool, or a pointer to one of those.
// Array types are not supported.
//
// By default, the local machine and default namespace are used. These can be
// changed using connectServerArgs. See
// http://msdn.microsoft.com/en-us/library/aa393720.aspx for details.
//
// Query is a wrapper around DefaultClient.Query.
func Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
if DefaultClient.SWbemServicesClient == nil {
return DefaultClient.Query(query, dst, connectServerArgs...)
}
return DefaultClient.SWbemServicesClient.Query(query, dst, connectServerArgs...)
}
// A Client is an WMI query client.
//
// Its zero value (DefaultClient) is a usable client.
type Client struct {
// NonePtrZero specifies if nil values for fields which aren't pointers
// should be returned as the field types zero value.
//
// Setting this to true allows stucts without pointer fields to be used
// without the risk failure should a nil value returned from WMI.
NonePtrZero bool
// PtrNil specifies if nil values for pointer fields should be returned
// as nil.
//
// Setting this to true will set pointer fields to nil where WMI
// returned nil, otherwise the types zero value will be returned.
PtrNil bool
// AllowMissingFields specifies that struct fields not present in the
// query result should not result in an error.
//
// Setting this to true allows custom queries to be used with full
// struct definitions instead of having to define multiple structs.
AllowMissingFields bool
// SWbemServiceClient is an optional SWbemServices object that can be
// initialized and then reused across multiple queries. If it is null
// then the method will initialize a new temporary client each time.
SWbemServicesClient *SWbemServices
}
// DefaultClient is the default Client and is used by Query, QueryNamespace
var DefaultClient = &Client{}
// Query runs the WQL query and appends the values to dst.
//
// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
// the query must have the same name in dst. Supported types are all signed and
// unsigned integers, time.Time, string, bool, or a pointer to one of those.
// Array types are not supported.
//
// By default, the local machine and default namespace are used. These can be
// changed using connectServerArgs. See
// http://msdn.microsoft.com/en-us/library/aa393720.aspx for details.
func (c *Client) Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
dv := reflect.ValueOf(dst)
if dv.Kind() != reflect.Ptr || dv.IsNil() {
return ErrInvalidEntityType
}
dv = dv.Elem()
mat, elemType := checkMultiArg(dv)
if mat == multiArgTypeInvalid {
return ErrInvalidEntityType
}
lock.Lock()
defer lock.Unlock()
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
if err != nil {
oleCode := err.(*ole.OleError).Code()
if oleCode != ole.S_OK && oleCode != S_FALSE {
return err
}
}
defer ole.CoUninitialize()
unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator")
if err != nil {
return err
} else if unknown == nil {
return ErrNilCreateObject
}
defer unknown.Release()
wmi, err := unknown.QueryInterface(ole.IID_IDispatch)
if err != nil {
return err
}
defer wmi.Release()
// service is a SWbemServices
serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer", connectServerArgs...)
if err != nil {
return err
}
service := serviceRaw.ToIDispatch()
defer serviceRaw.Clear()
// result is a SWBemObjectSet
resultRaw, err := oleutil.CallMethod(service, "ExecQuery", query)
if err != nil {
return err
}
result := resultRaw.ToIDispatch()
defer resultRaw.Clear()
count, err := oleInt64(result, "Count")
if err != nil {
return err
}
enumProperty, err := result.GetProperty("_NewEnum")
if err != nil {
return err
}
defer enumProperty.Clear()
enum, err := enumProperty.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
if err != nil {
return err
}
if enum == nil {
return fmt.Errorf("can't get IEnumVARIANT, enum is nil")
}
defer enum.Release()
// Initialize a slice with Count capacity
dv.Set(reflect.MakeSlice(dv.Type(), 0, int(count)))
var errFieldMismatch error
for itemRaw, length, err := enum.Next(1); length > 0; itemRaw, length, err = enum.Next(1) {
if err != nil {
return err
}
err := func() error {
// item is a SWbemObject, but really a Win32_Process
item := itemRaw.ToIDispatch()
defer item.Release()
ev := reflect.New(elemType)
if err = c.loadEntity(ev.Interface(), item); err != nil {
if _, ok := err.(*ErrFieldMismatch); ok {
// We continue loading entities even in the face of field mismatch errors.
// If we encounter any other error, that other error is returned. Otherwise,
// an ErrFieldMismatch is returned.
errFieldMismatch = err
} else {
return err
}
}
if mat != multiArgTypeStructPtr {
ev = ev.Elem()
}
dv.Set(reflect.Append(dv, ev))
return nil
}()
if err != nil {
return err
}
}
return errFieldMismatch
}
// ErrFieldMismatch is returned when a field is to be loaded into a different
// type than the one it was stored from, or when a field is missing or
// unexported in the destination struct.
// StructType is the type of the struct pointed to by the destination argument.
type ErrFieldMismatch struct {
StructType reflect.Type
FieldName string
Reason string
}
func (e *ErrFieldMismatch) Error() string {
return fmt.Sprintf("wmi: cannot load field %q into a %q: %s",
e.FieldName, e.StructType, e.Reason)
}
var timeType = reflect.TypeOf(time.Time{})
// loadEntity loads a SWbemObject into a struct pointer.
func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismatch error) {
v := reflect.ValueOf(dst).Elem()
for i := 0; i < v.NumField(); i++ {
f := v.Field(i)
of := f
isPtr := f.Kind() == reflect.Ptr
if isPtr {
ptr := reflect.New(f.Type().Elem())
f.Set(ptr)
f = f.Elem()
}
n := v.Type().Field(i).Name
if !f.CanSet() {
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "CanSet() is false",
}
}
prop, err := oleutil.GetProperty(src, n)
if err != nil {
if !c.AllowMissingFields {
errFieldMismatch = &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "no such struct field",
}
}
continue
}
defer prop.Clear()
switch val := prop.Value().(type) {
case int8, int16, int32, int64, int:
v := reflect.ValueOf(val).Int()
switch f.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
f.SetInt(v)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
f.SetUint(uint64(v))
default:
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "not an integer class",
}
}
case uint8, uint16, uint32, uint64:
v := reflect.ValueOf(val).Uint()
switch f.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
f.SetInt(int64(v))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
f.SetUint(v)
default:
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "not an integer class",
}
}
case string:
switch f.Kind() {
case reflect.String:
f.SetString(val)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
iv, err := strconv.ParseInt(val, 10, 64)
if err != nil {
return err
}
f.SetInt(iv)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
uv, err := strconv.ParseUint(val, 10, 64)
if err != nil {
return err
}
f.SetUint(uv)
case reflect.Struct:
switch f.Type() {
case timeType:
if len(val) == 25 {
mins, err := strconv.Atoi(val[22:])
if err != nil {
return err
}
val = val[:22] + fmt.Sprintf("%02d%02d", mins/60, mins%60)
}
t, err := time.Parse("20060102150405.000000-0700", val)
if err != nil {
return err
}
f.Set(reflect.ValueOf(t))
}
}
case bool:
switch f.Kind() {
case reflect.Bool:
f.SetBool(val)
default:
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "not a bool",
}
}
case float32:
switch f.Kind() {
case reflect.Float32:
f.SetFloat(float64(val))
default:
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: "not a Float32",
}
}
default:
// Only support []string slices for now
if f.Kind() == reflect.Slice && f.Type().Elem().Kind() == reflect.String {
safeArray := prop.ToArray()
if safeArray != nil {
arr := safeArray.ToValueArray()
fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr))
for i, v := range arr {
s := fArr.Index(i)
s.SetString(v.(string))
}
f.Set(fArr)
break
}
}
typeof := reflect.TypeOf(val)
if typeof == nil && (isPtr || c.NonePtrZero) {
if (isPtr && c.PtrNil) || (!isPtr && c.NonePtrZero) {
of.Set(reflect.Zero(of.Type()))
}
break
}
return &ErrFieldMismatch{
StructType: of.Type(),
FieldName: n,
Reason: fmt.Sprintf("unsupported type (%T)", val),
}
}
}
return errFieldMismatch
}
type multiArgType int
const (
multiArgTypeInvalid multiArgType = iota
multiArgTypeStruct
multiArgTypeStructPtr
)
// checkMultiArg checks that v has type []S, []*S for some struct type S.
//
// It returns what category the slice's elements are, and the reflect.Type
// that represents S.
func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) {
if v.Kind() != reflect.Slice {
return multiArgTypeInvalid, nil
}
elemType = v.Type().Elem()
switch elemType.Kind() {
case reflect.Struct:
return multiArgTypeStruct, elemType
case reflect.Ptr:
elemType = elemType.Elem()
if elemType.Kind() == reflect.Struct {
return multiArgTypeStructPtr, elemType
}
}
return multiArgTypeInvalid, nil
}
func oleInt64(item *ole.IDispatch, prop string) (int64, error) {
v, err := oleutil.GetProperty(item, prop)
if err != nil {
return 0, err
}
defer v.Clear()
i := int64(v.Val)
return i, nil
}
// CreateQuery returns a WQL query string that queries all columns of src. where
// is an optional string that is appended to the query, to be used with WHERE
// clauses. In such a case, the "WHERE" string should appear at the beginning.
func CreateQuery(src interface{}, where string) string {
var b bytes.Buffer
b.WriteString("SELECT ")
s := reflect.Indirect(reflect.ValueOf(src))
t := s.Type()
if s.Kind() == reflect.Slice {
t = t.Elem()
}
if t.Kind() != reflect.Struct {
return ""
}
var fields []string
for i := 0; i < t.NumField(); i++ {
fields = append(fields, t.Field(i).Name)
}
b.WriteString(strings.Join(fields, ", "))
b.WriteString(" FROM ")
b.WriteString(t.Name())
b.WriteString(" " + where)
return b.String()
}

544
gosuper/vendor/github.com/StackExchange/wmi/wmi_test.go generated vendored
View File

@ -1,544 +0,0 @@
// +build windows
package wmi
import (
"encoding/json"
"fmt"
"os"
"reflect"
"runtime"
"runtime/debug"
"sync"
"testing"
"time"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
func TestQuery(t *testing.T) {
var dst []Win32_Process
q := CreateQuery(&dst, "")
err := Query(q, &dst)
if err != nil {
t.Fatal(err)
}
}
func TestFieldMismatch(t *testing.T) {
type s struct {
Name string
HandleCount uint32
Blah uint32
}
var dst []s
err := Query("SELECT Name, HandleCount FROM Win32_Process", &dst)
if err == nil || err.Error() != `wmi: cannot load field "Blah" into a "uint32": no such struct field` {
t.Error("Expected err field mismatch")
}
}
func TestStrings(t *testing.T) {
printed := false
f := func() {
var dst []Win32_Process
zeros := 0
q := CreateQuery(&dst, "")
for i := 0; i < 5; i++ {
err := Query(q, &dst)
if err != nil {
t.Fatal(err, q)
}
for _, d := range dst {
v := reflect.ValueOf(d)
for j := 0; j < v.NumField(); j++ {
f := v.Field(j)
if f.Kind() != reflect.String {
continue
}
s := f.Interface().(string)
if len(s) > 0 && s[0] == '\u0000' {
zeros++
if !printed {
printed = true
j, _ := json.MarshalIndent(&d, "", " ")
t.Log("Example with \\u0000:\n", string(j))
}
}
}
}
fmt.Println("iter", i, "zeros:", zeros)
}
if zeros > 0 {
t.Error("> 0 zeros")
}
}
fmt.Println("Disabling GC")
debug.SetGCPercent(-1)
f()
fmt.Println("Enabling GC")
debug.SetGCPercent(100)
f()
}
func TestNamespace(t *testing.T) {
var dst []Win32_Process
q := CreateQuery(&dst, "")
err := QueryNamespace(q, &dst, `root\CIMV2`)
if err != nil {
t.Fatal(err)
}
dst = nil
err = QueryNamespace(q, &dst, `broken\nothing`)
if err == nil {
t.Fatal("expected error")
}
}
func TestCreateQuery(t *testing.T) {
type TestStruct struct {
Name string
Count int
}
var dst []TestStruct
output := "SELECT Name, Count FROM TestStruct WHERE Count > 2"
tests := []interface{}{
&dst,
dst,
TestStruct{},
&TestStruct{},
}
for i, test := range tests {
if o := CreateQuery(test, "WHERE Count > 2"); o != output {
t.Error("bad output on", i, o)
}
}
if CreateQuery(3, "") != "" {
t.Error("expected empty string")
}
}
// Run using: go test -run TestMemoryWMISimple -timeout 60m
func _TestMemoryWMISimple(t *testing.T) {
start := time.Now()
limit := 500000
fmt.Printf("Benchmark Iterations: %d (Memory should stabilize around 7MB after ~3000)\n", limit)
var privateMB, allocMB, allocTotalMB float64
//var dst []Win32_PerfRawData_PerfDisk_LogicalDisk
//q := CreateQuery(&dst, "")
for i := 0; i < limit; i++ {
privateMB, allocMB, allocTotalMB = GetMemoryUsageMB()
if i%1000 == 0 {
//privateMB, allocMB, allocTotalMB = GetMemoryUsageMB()
fmt.Printf("Time: %4ds Count: %5d Private Memory: %5.1fMB MemStats.Alloc: %4.1fMB MemStats.TotalAlloc: %5.1fMB\n", time.Now().Sub(start)/time.Second, i, privateMB, allocMB, allocTotalMB)
}
//Query(q, &dst)
}
//privateMB, allocMB, allocTotalMB = GetMemoryUsageMB()
fmt.Printf("Final Time: %4ds Private Memory: %5.1fMB MemStats.Alloc: %4.1fMB MemStats.TotalAlloc: %5.1fMB\n", time.Now().Sub(start)/time.Second, privateMB, allocMB, allocTotalMB)
}
func _TestMemoryWMIConcurrent(t *testing.T) {
if testing.Short() {
return
}
start := time.Now()
limit := 50000
fmt.Println("Total Iterations:", limit)
fmt.Println("No panics mean it succeeded. Other errors are OK. Memory should stabilize after ~1500 iterations.")
runtime.GOMAXPROCS(2)
wg := sync.WaitGroup{}
wg.Add(2)
go func() {
for i := 0; i < limit; i++ {
if i%500 == 0 {
privateMB, allocMB, allocTotalMB := GetMemoryUsageMB()
fmt.Printf("Time: %4ds Count: %4d Private Memory: %5.1fMB MemStats.Alloc: %4.1fMB MemStats.TotalAlloc: %5.1fMB\n", time.Now().Sub(start)/time.Second, i, privateMB, allocMB, allocTotalMB)
}
var dst []Win32_PerfRawData_PerfDisk_LogicalDisk
q := CreateQuery(&dst, "")
err := Query(q, &dst)
if err != nil {
fmt.Println("ERROR disk", err)
}
}
wg.Done()
}()
go func() {
for i := 0; i > -limit; i-- {
//if i%500 == 0 {
// fmt.Println(i)
//}
var dst []Win32_OperatingSystem
q := CreateQuery(&dst, "")
err := Query(q, &dst)
if err != nil {
fmt.Println("ERROR OS", err)
}
}
wg.Done()
}()
wg.Wait()
//privateMB, allocMB, allocTotalMB := GetMemoryUsageMB()
//fmt.Printf("Final Private Memory: %5.1fMB MemStats.Alloc: %4.1fMB MemStats.TotalAlloc: %5.1fMB\n", privateMB, allocMB, allocTotalMB)
}
var lockthread sync.Mutex
var refcount1 int32
var refcount2 int32
var refcount3 int32
// Test function showing memory leak in unknown.QueryInterface call on Server2016/Windows10
func getRSS(url string, xmlhttp *ole.IDispatch, MinimalTest bool) (int, error) {
// call using url,nil to see memory leak
if xmlhttp == nil {
//Initialize inside loop if not passed in from outer section
lockthread.Lock()
defer lockthread.Unlock()
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
if err != nil {
oleCode := err.(*ole.OleError).Code()
if oleCode != ole.S_OK && oleCode != S_FALSE {
return 0, err
}
}
defer ole.CoUninitialize()
//fmt.Println("CreateObject Microsoft.XMLHTTP")
unknown, err := oleutil.CreateObject("Microsoft.XMLHTTP")
if err != nil {
return 0, err
}
defer func() { refcount1 += xmlhttp.Release() }()
//Memory leak occurs here
xmlhttp, err = unknown.QueryInterface(ole.IID_IDispatch)
if err != nil {
return 0, err
}
defer func() { refcount2 += xmlhttp.Release() }()
//Nothing below this really matters. Can be removed if you want a tighter loop
}
//fmt.Printf("Download %s\n", url)
openRaw, err := oleutil.CallMethod(xmlhttp, "open", "GET", url, false)
if err != nil {
return 0, err
}
defer openRaw.Clear()
if MinimalTest {
return 1, nil
}
//Initiate http request
sendRaw, err := oleutil.CallMethod(xmlhttp, "send", nil)
if err != nil {
return 0, err
}
defer sendRaw.Clear()
state := -1 // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState
for state != 4 {
time.Sleep(5 * time.Millisecond)
stateRaw := oleutil.MustGetProperty(xmlhttp, "readyState")
state = int(stateRaw.Val)
stateRaw.Clear()
}
responseXMLRaw := oleutil.MustGetProperty(xmlhttp, "responseXml")
responseXML := responseXMLRaw.ToIDispatch()
defer responseXMLRaw.Clear()
itemsRaw := oleutil.MustCallMethod(responseXML, "selectNodes", "/rdf:RDF/item")
items := itemsRaw.ToIDispatch()
defer itemsRaw.Clear()
lengthRaw := oleutil.MustGetProperty(items, "length")
defer lengthRaw.Clear()
length := int(lengthRaw.Val)
/* This just bloats the TotalAlloc and slows the test down. Doesn't effect Private Working Set
for n := 0; n < length; n++ {
itemRaw := oleutil.MustGetProperty(items, "item", n)
item := itemRaw.ToIDispatch()
title := oleutil.MustCallMethod(item, "selectSingleNode", "title").ToIDispatch()
//fmt.Println(oleutil.MustGetProperty(title, "text").ToString())
textRaw := oleutil.MustGetProperty(title, "text")
textRaw.ToString()
link := oleutil.MustCallMethod(item, "selectSingleNode", "link").ToIDispatch()
//fmt.Println(" " + oleutil.MustGetProperty(link, "text").ToString())
textRaw2 := oleutil.MustGetProperty(link, "text")
textRaw2.ToString()
textRaw2.Clear()
link.Release()
textRaw.Clear()
title.Release()
itemRaw.Clear()
}
*/
return length, nil
}
// Testing go-ole/oleutil
// Run using: go test -run TestMemoryOLE -timeout 60m
// Code from https://github.com/go-ole/go-ole/blob/master/example/msxml/rssreader.go
func _TestMemoryOLE(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Error(r)
}
}()
start := time.Now()
limit := 50000000
url := "http://localhost/slashdot.xml" //http://rss.slashdot.org/Slashdot/slashdot"
fmt.Printf("Benchmark Iterations: %d (Memory should stabilize around 8MB to 12MB after ~2k full or 250k minimal)\n", limit)
//On Server 2016 or Windows 10 changing leakMemory=true will cause it to leak ~1.5MB per 10000 calls to unknown.QueryInterface
leakMemory := true
////////////////////////////////////////
//Start outer section
var unknown *ole.IUnknown
var xmlhttp *ole.IDispatch
if !leakMemory {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
if err != nil {
oleCode := err.(*ole.OleError).Code()
if oleCode != ole.S_OK && oleCode != S_FALSE {
t.Fatal(err)
}
}
defer ole.CoUninitialize()
//fmt.Println("CreateObject Microsoft.XMLHTTP")
unknown, err = oleutil.CreateObject("Microsoft.XMLHTTP")
if err != nil {
t.Fatal(err)
}
defer unknown.Release()
//Memory leak starts here
xmlhttp, err = unknown.QueryInterface(ole.IID_IDispatch)
if err != nil {
t.Fatal(err)
}
defer xmlhttp.Release()
}
//End outer section
////////////////////////////////////////
totalItems := uint64(0)
for i := 0; i < limit; i++ {
if i%2000 == 0 {
privateMB, allocMB, allocTotalMB := GetMemoryUsageMB()
fmt.Printf("Time: %4ds Count: %7d Private Memory: %5.1fMB MemStats.Alloc: %4.1fMB MemStats.TotalAlloc: %5.1fMB %7d/%7d\n", time.Now().Sub(start)/time.Second, i, privateMB, allocMB, allocTotalMB, refcount1, refcount2)
}
//This should use less than 10MB for 1 million iterations if xmlhttp was initialized above
//On Server 2016 or Windows 10 changing leakMemory=true above will cause it to leak ~1.5MB per 10000 calls to unknown.QueryInterface
count, err := getRSS(url, xmlhttp, true) //last argument is for Minimal test. Doesn't effect leak just overall allocations/time
if err != nil {
t.Fatal(err)
}
totalItems += uint64(count)
}
privateMB, allocMB, allocTotalMB := GetMemoryUsageMB()
fmt.Printf("Final totalItems: %d Private Memory: %5.1fMB MemStats.Alloc: %4.1fMB MemStats.TotalAlloc: %5.1fMB\n", totalItems, privateMB, allocMB, allocTotalMB)
}
const MB = 1024 * 1024
var (
mMemoryUsageMB runtime.MemStats
errGetMemoryUsageMB error
dstGetMemoryUsageMB []Win32_PerfRawData_PerfProc_Process
filterProcessID = fmt.Sprintf("WHERE IDProcess = %d", os.Getpid())
qGetMemoryUsageMB = CreateQuery(&dstGetMemoryUsageMB, filterProcessID)
)
func GetMemoryUsageMB() (float64, float64, float64) {
runtime.ReadMemStats(&mMemoryUsageMB)
//errGetMemoryUsageMB = nil //Query(qGetMemoryUsageMB, &dstGetMemoryUsageMB) float64(dstGetMemoryUsageMB[0].WorkingSetPrivate)
errGetMemoryUsageMB = Query(qGetMemoryUsageMB, &dstGetMemoryUsageMB)
if errGetMemoryUsageMB != nil {
fmt.Println("ERROR GetMemoryUsage", errGetMemoryUsageMB)
return 0, 0, 0
}
return float64(dstGetMemoryUsageMB[0].WorkingSetPrivate) / MB, float64(mMemoryUsageMB.Alloc) / MB, float64(mMemoryUsageMB.TotalAlloc) / MB
}
type Win32_PerfRawData_PerfProc_Process struct {
IDProcess uint32
WorkingSetPrivate uint64
}
type Win32_Process struct {
CSCreationClassName string
CSName string
Caption *string
CommandLine *string
CreationClassName string
CreationDate *time.Time
Description *string
ExecutablePath *string
ExecutionState *uint16
Handle string
HandleCount uint32
InstallDate *time.Time
KernelModeTime uint64
MaximumWorkingSetSize *uint32
MinimumWorkingSetSize *uint32
Name string
OSCreationClassName string
OSName string
OtherOperationCount uint64
OtherTransferCount uint64
PageFaults uint32
PageFileUsage uint32
ParentProcessId uint32
PeakPageFileUsage uint32
PeakVirtualSize uint64
PeakWorkingSetSize uint32
Priority uint32
PrivatePageCount uint64
ProcessId uint32
QuotaNonPagedPoolUsage uint32
QuotaPagedPoolUsage uint32
QuotaPeakNonPagedPoolUsage uint32
QuotaPeakPagedPoolUsage uint32
ReadOperationCount uint64
ReadTransferCount uint64
SessionId uint32
Status *string
TerminationDate *time.Time
ThreadCount uint32
UserModeTime uint64
VirtualSize uint64
WindowsVersion string
WorkingSetSize uint64
WriteOperationCount uint64
WriteTransferCount uint64
}
type Win32_PerfRawData_PerfDisk_LogicalDisk struct {
AvgDiskBytesPerRead uint64
AvgDiskBytesPerRead_Base uint32
AvgDiskBytesPerTransfer uint64
AvgDiskBytesPerTransfer_Base uint32
AvgDiskBytesPerWrite uint64
AvgDiskBytesPerWrite_Base uint32
AvgDiskQueueLength uint64
AvgDiskReadQueueLength uint64
AvgDiskSecPerRead uint32
AvgDiskSecPerRead_Base uint32
AvgDiskSecPerTransfer uint32
AvgDiskSecPerTransfer_Base uint32
AvgDiskSecPerWrite uint32
AvgDiskSecPerWrite_Base uint32
AvgDiskWriteQueueLength uint64
Caption *string
CurrentDiskQueueLength uint32
Description *string
DiskBytesPerSec uint64
DiskReadBytesPerSec uint64
DiskReadsPerSec uint32
DiskTransfersPerSec uint32
DiskWriteBytesPerSec uint64
DiskWritesPerSec uint32
FreeMegabytes uint32
Frequency_Object uint64
Frequency_PerfTime uint64
Frequency_Sys100NS uint64
Name string
PercentDiskReadTime uint64
PercentDiskReadTime_Base uint64
PercentDiskTime uint64
PercentDiskTime_Base uint64
PercentDiskWriteTime uint64
PercentDiskWriteTime_Base uint64
PercentFreeSpace uint32
PercentFreeSpace_Base uint32
PercentIdleTime uint64
PercentIdleTime_Base uint64
SplitIOPerSec uint32
Timestamp_Object uint64
Timestamp_PerfTime uint64
Timestamp_Sys100NS uint64
}
type Win32_OperatingSystem struct {
BootDevice string
BuildNumber string
BuildType string
Caption *string
CodeSet string
CountryCode string
CreationClassName string
CSCreationClassName string
CSDVersion *string
CSName string
CurrentTimeZone int16
DataExecutionPrevention_Available bool
DataExecutionPrevention_32BitApplications bool
DataExecutionPrevention_Drivers bool
DataExecutionPrevention_SupportPolicy *uint8
Debug bool
Description *string
Distributed bool
EncryptionLevel uint32
ForegroundApplicationBoost *uint8
FreePhysicalMemory uint64
FreeSpaceInPagingFiles uint64
FreeVirtualMemory uint64
InstallDate time.Time
LargeSystemCache *uint32
LastBootUpTime time.Time
LocalDateTime time.Time
Locale string
Manufacturer string
MaxNumberOfProcesses uint32
MaxProcessMemorySize uint64
MUILanguages *[]string
Name string
NumberOfLicensedUsers *uint32
NumberOfProcesses uint32
NumberOfUsers uint32
OperatingSystemSKU uint32
Organization string
OSArchitecture string
OSLanguage uint32
OSProductSuite uint32
OSType uint16
OtherTypeDescription *string
PAEEnabled *bool
PlusProductID *string
PlusVersionNumber *string
PortableOperatingSystem bool
Primary bool
ProductType uint32
RegisteredUser string
SerialNumber string
ServicePackMajorVersion uint16
ServicePackMinorVersion uint16
SizeStoredInPagingFiles uint64
Status string
SuiteMask uint32
SystemDevice string
SystemDirectory string
SystemDrive string
TotalSwapSpaceSize *uint64
TotalVirtualMemorySize uint64
TotalVisibleMemorySize uint64
Version string
WindowsDirectory string
}

67
gosuper/vendor/github.com/docker/go-units/CONTRIBUTING.md generated vendored
View File

@ -1,67 +0,0 @@
# Contributing to go-units
Want to hack on go-units? Awesome! Here are instructions to get you started.
go-units is a part of the [Docker](https://www.docker.com) project, and follows
the same rules and principles. If you're already familiar with the way
Docker does things, you'll feel right at home.
Otherwise, go read Docker's
[contributions guidelines](https://github.com/docker/docker/blob/master/CONTRIBUTING.md),
[issue triaging](https://github.com/docker/docker/blob/master/project/ISSUE-TRIAGE.md),
[review process](https://github.com/docker/docker/blob/master/project/REVIEWING.md) and
[branches and tags](https://github.com/docker/docker/blob/master/project/BRANCHES-AND-TAGS.md).
### Sign your work
The sign-off is a simple line at the end of the explanation for the patch. Your
signature certifies that you wrote the patch or otherwise have the right to pass
it on as an open-source patch. The rules are pretty simple: if you can certify
the below (from [developercertificate.org](http://developercertificate.org/)):
```
Developer Certificate of Origin
Version 1.1
Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
660 York Street, Suite 102,
San Francisco, CA 94110 USA
Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.
Developer's Certificate of Origin 1.1
By making a contribution to this project, I certify that:
(a) The contribution was created in whole or in part by me and I
have the right to submit it under the open source license
indicated in the file; or
(b) The contribution is based upon previous work that, to the best
of my knowledge, is covered under an appropriate open source
license and I have the right under that license to submit that
work with modifications, whether created in whole or in part
by me, under the same open source license (unless I am
permitted to submit under a different license), as indicated
in the file; or
(c) The contribution was provided directly to me by some other
person who certified (a), (b) or (c) and I have not modified
it.
(d) I understand and agree that this project and the contribution
are public and that a record of the contribution (including all
personal information I submit with it, including my sign-off) is
maintained indefinitely and may be redistributed consistent with
this project or the open source license(s) involved.
```
Then you just add a line to every git commit message:
Signed-off-by: Joe Smith <joe.smith@email.com>
Use your real name (sorry, no pseudonyms or anonymous contributions.)
If you set your `user.name` and `user.email` git configs, you can sign your
commit automatically with `git commit -s`.

191
gosuper/vendor/github.com/docker/go-units/LICENSE generated vendored
View File

@ -1,191 +0,0 @@
Apache License
Version 2.0, January 2004
https://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
Copyright 2015 Docker, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

27
gosuper/vendor/github.com/docker/go-units/MAINTAINERS generated vendored
View File

@ -1,27 +0,0 @@
# go-connections maintainers file
#
# This file describes who runs the docker/go-connections project and how.
# This is a living document - if you see something out of date or missing, speak up!
#
# It is structured to be consumable by both humans and programs.
# To extract its contents programmatically, use any TOML-compliant parser.
#
# This file is compiled into the MAINTAINERS file in docker/opensource.
#
[Org]
[Org."Core maintainers"]
people = [
"calavera",
]
[people]
# A reference list of all people associated with the project.
# All other sections should refer to people by their canonical key
# in the people section.
# ADD YOURSELF HERE IN ALPHABETICAL ORDER
[people.calavera]
Name = "David Calavera"
Email = "david.calavera@gmail.com"
GitHub = "calavera"

16
gosuper/vendor/github.com/docker/go-units/README.md generated vendored
View File

@ -1,16 +0,0 @@
[![GoDoc](https://godoc.org/github.com/docker/go-units?status.svg)](https://godoc.org/github.com/docker/go-units)
# Introduction
go-units is a library to transform human friendly measurements into machine friendly values.
## Usage
See the [docs in godoc](https://godoc.org/github.com/docker/go-units) for examples and documentation.
## Copyright and license
Copyright © 2015 Docker, Inc.
go-units is licensed under the Apache License, Version 2.0.
See [LICENSE](LICENSE) for the full text of the license.

11
gosuper/vendor/github.com/docker/go-units/circle.yml generated vendored
View File

@ -1,11 +0,0 @@
dependencies:
post:
# install golint
- go get github.com/golang/lint/golint
test:
pre:
# run analysis before tests
- go vet ./...
- test -z "$(golint ./... | tee /dev/stderr)"
- test -z "$(gofmt -s -l . | tee /dev/stderr)"

35
gosuper/vendor/github.com/docker/go-units/duration.go generated vendored
View File

@ -1,35 +0,0 @@
// Package units provides helper function to parse and print size and time units
// in human-readable format.
package units
import (
"fmt"
"time"
)
// HumanDuration returns a human-readable approximation of a duration
// (eg. "About a minute", "4 hours ago", etc.).
func HumanDuration(d time.Duration) string {
if seconds := int(d.Seconds()); seconds < 1 {
return "Less than a second"
} else if seconds == 1 {
return "1 second"
} else if seconds < 60 {
return fmt.Sprintf("%d seconds", seconds)
} else if minutes := int(d.Minutes()); minutes == 1 {
return "About a minute"
} else if minutes < 46 {
return fmt.Sprintf("%d minutes", minutes)
} else if hours := int(d.Hours() + 0.5); hours == 1 {
return "About an hour"
} else if hours < 48 {
return fmt.Sprintf("%d hours", hours)
} else if hours < 24*7*2 {
return fmt.Sprintf("%d days", hours/24)
} else if hours < 24*30*2 {
return fmt.Sprintf("%d weeks", hours/24/7)
} else if hours < 24*365*2 {
return fmt.Sprintf("%d months", hours/24/30)
}
return fmt.Sprintf("%d years", int(d.Hours())/24/365)
}

95
gosuper/vendor/github.com/docker/go-units/duration_test.go generated vendored
View File

@ -1,95 +0,0 @@
package units
import (
"fmt"
"testing"
"time"
)
func ExampleHumanDuration() {
fmt.Println(HumanDuration(450 * time.Millisecond))
fmt.Println(HumanDuration(47 * time.Second))
fmt.Println(HumanDuration(1 * time.Minute))
fmt.Println(HumanDuration(3 * time.Minute))
fmt.Println(HumanDuration(35 * time.Minute))
fmt.Println(HumanDuration(35*time.Minute + 40*time.Second))
fmt.Println(HumanDuration(1 * time.Hour))
fmt.Println(HumanDuration(1*time.Hour + 45*time.Minute))
fmt.Println(HumanDuration(3 * time.Hour))
fmt.Println(HumanDuration(3*time.Hour + 59*time.Minute))
fmt.Println(HumanDuration(3*time.Hour + 60*time.Minute))
fmt.Println(HumanDuration(24 * time.Hour))
fmt.Println(HumanDuration(24*time.Hour + 12*time.Hour))
fmt.Println(HumanDuration(2 * 24 * time.Hour))
fmt.Println(HumanDuration(7 * 24 * time.Hour))
fmt.Println(HumanDuration(13*24*time.Hour + 5*time.Hour))
fmt.Println(HumanDuration(2 * 7 * 24 * time.Hour))
fmt.Println(HumanDuration(2*7*24*time.Hour + 4*24*time.Hour))
fmt.Println(HumanDuration(3 * 7 * 24 * time.Hour))
fmt.Println(HumanDuration(4 * 7 * 24 * time.Hour))
fmt.Println(HumanDuration(4*7*24*time.Hour + 3*24*time.Hour))
fmt.Println(HumanDuration(1 * 30 * 24 * time.Hour))
fmt.Println(HumanDuration(1*30*24*time.Hour + 2*7*24*time.Hour))
fmt.Println(HumanDuration(2 * 30 * 24 * time.Hour))
fmt.Println(HumanDuration(3*30*24*time.Hour + 1*7*24*time.Hour))
fmt.Println(HumanDuration(5*30*24*time.Hour + 2*7*24*time.Hour))
fmt.Println(HumanDuration(13 * 30 * 24 * time.Hour))
fmt.Println(HumanDuration(23 * 30 * 24 * time.Hour))
fmt.Println(HumanDuration(24 * 30 * 24 * time.Hour))
fmt.Println(HumanDuration(24*30*24*time.Hour + 2*7*24*time.Hour))
fmt.Println(HumanDuration(3*365*24*time.Hour + 2*30*24*time.Hour))
}
func TestHumanDuration(t *testing.T) {
// Useful duration abstractions
day := 24 * time.Hour
week := 7 * day
month := 30 * day
year := 365 * day
assertEquals(t, "Less than a second", HumanDuration(450*time.Millisecond))
assertEquals(t, "1 second", HumanDuration(1*time.Second))
assertEquals(t, "45 seconds", HumanDuration(45*time.Second))
assertEquals(t, "46 seconds", HumanDuration(46*time.Second))
assertEquals(t, "59 seconds", HumanDuration(59*time.Second))
assertEquals(t, "About a minute", HumanDuration(60*time.Second))
assertEquals(t, "About a minute", HumanDuration(1*time.Minute))
assertEquals(t, "3 minutes", HumanDuration(3*time.Minute))
assertEquals(t, "35 minutes", HumanDuration(35*time.Minute))
assertEquals(t, "35 minutes", HumanDuration(35*time.Minute+40*time.Second))
assertEquals(t, "45 minutes", HumanDuration(45*time.Minute))
assertEquals(t, "45 minutes", HumanDuration(45*time.Minute+40*time.Second))
assertEquals(t, "About an hour", HumanDuration(46*time.Minute))
assertEquals(t, "About an hour", HumanDuration(59*time.Minute))
assertEquals(t, "About an hour", HumanDuration(1*time.Hour))
assertEquals(t, "About an hour", HumanDuration(1*time.Hour+29*time.Minute))
assertEquals(t, "2 hours", HumanDuration(1*time.Hour+31*time.Minute))
assertEquals(t, "2 hours", HumanDuration(1*time.Hour+59*time.Minute))
assertEquals(t, "3 hours", HumanDuration(3*time.Hour))
assertEquals(t, "3 hours", HumanDuration(3*time.Hour+29*time.Minute))
assertEquals(t, "4 hours", HumanDuration(3*time.Hour+31*time.Minute))
assertEquals(t, "4 hours", HumanDuration(3*time.Hour+59*time.Minute))
assertEquals(t, "4 hours", HumanDuration(3*time.Hour+60*time.Minute))
assertEquals(t, "24 hours", HumanDuration(24*time.Hour))
assertEquals(t, "36 hours", HumanDuration(1*day+12*time.Hour))
assertEquals(t, "2 days", HumanDuration(2*day))
assertEquals(t, "7 days", HumanDuration(7*day))
assertEquals(t, "13 days", HumanDuration(13*day+5*time.Hour))
assertEquals(t, "2 weeks", HumanDuration(2*week))
assertEquals(t, "2 weeks", HumanDuration(2*week+4*day))
assertEquals(t, "3 weeks", HumanDuration(3*week))
assertEquals(t, "4 weeks", HumanDuration(4*week))
assertEquals(t, "4 weeks", HumanDuration(4*week+3*day))
assertEquals(t, "4 weeks", HumanDuration(1*month))
assertEquals(t, "6 weeks", HumanDuration(1*month+2*week))
assertEquals(t, "2 months", HumanDuration(2*month))
assertEquals(t, "2 months", HumanDuration(2*month+2*week))
assertEquals(t, "3 months", HumanDuration(3*month))
assertEquals(t, "3 months", HumanDuration(3*month+1*week))
assertEquals(t, "5 months", HumanDuration(5*month+2*week))
assertEquals(t, "13 months", HumanDuration(13*month))
assertEquals(t, "23 months", HumanDuration(23*month))
assertEquals(t, "24 months", HumanDuration(24*month))
assertEquals(t, "2 years", HumanDuration(24*month+2*week))
assertEquals(t, "3 years", HumanDuration(3*year+2*month))
}

108
gosuper/vendor/github.com/docker/go-units/size.go generated vendored
View File

@ -1,108 +0,0 @@
package units
import (
"fmt"
"regexp"
"strconv"
"strings"
)
// See: http://en.wikipedia.org/wiki/Binary_prefix
const (
// Decimal
KB = 1000
MB = 1000 * KB
GB = 1000 * MB
TB = 1000 * GB
PB = 1000 * TB
// Binary
KiB = 1024
MiB = 1024 * KiB
GiB = 1024 * MiB
TiB = 1024 * GiB
PiB = 1024 * TiB
)
type unitMap map[string]int64
var (
decimalMap = unitMap{"k": KB, "m": MB, "g": GB, "t": TB, "p": PB}
binaryMap = unitMap{"k": KiB, "m": MiB, "g": GiB, "t": TiB, "p": PiB}
sizeRegex = regexp.MustCompile(`^(\d+(\.\d+)*) ?([kKmMgGtTpP])?[bB]?$`)
)
var decimapAbbrs = []string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"}
var binaryAbbrs = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"}
func getSizeAndUnit(size float64, base float64, _map []string) (float64, string) {
i := 0
unitsLimit := len(_map) - 1
for size >= base && i < unitsLimit {
size = size / base
i++
}
return size, _map[i]
}
// CustomSize returns a human-readable approximation of a size
// using custom format.
func CustomSize(format string, size float64, base float64, _map []string) string {
size, unit := getSizeAndUnit(size, base, _map)
return fmt.Sprintf(format, size, unit)
}
// HumanSizeWithPrecision allows the size to be in any precision,
// instead of 4 digit precision used in units.HumanSize.
func HumanSizeWithPrecision(size float64, precision int) string {
size, unit := getSizeAndUnit(size, 1000.0, decimapAbbrs)
return fmt.Sprintf("%.*g%s", precision, size, unit)
}
// HumanSize returns a human-readable approximation of a size
// capped at 4 valid numbers (eg. "2.746 MB", "796 KB").
func HumanSize(size float64) string {
return HumanSizeWithPrecision(size, 4)
}
// BytesSize returns a human-readable size in bytes, kibibytes,
// mebibytes, gibibytes, or tebibytes (eg. "44kiB", "17MiB").
func BytesSize(size float64) string {
return CustomSize("%.4g%s", size, 1024.0, binaryAbbrs)
}
// FromHumanSize returns an integer from a human-readable specification of a
// size using SI standard (eg. "44kB", "17MB").
func FromHumanSize(size string) (int64, error) {
return parseSize(size, decimalMap)
}
// RAMInBytes parses a human-readable string representing an amount of RAM
// in bytes, kibibytes, mebibytes, gibibytes, or tebibytes and
// returns the number of bytes, or -1 if the string is unparseable.
// Units are case-insensitive, and the 'b' suffix is optional.
func RAMInBytes(size string) (int64, error) {
return parseSize(size, binaryMap)
}
// Parses the human-readable size string into the amount it represents.
func parseSize(sizeStr string, uMap unitMap) (int64, error) {
matches := sizeRegex.FindStringSubmatch(sizeStr)
if len(matches) != 4 {
return -1, fmt.Errorf("invalid size: '%s'", sizeStr)
}
size, err := strconv.ParseFloat(matches[1], 64)
if err != nil {
return -1, err
}
unitPrefix := strings.ToLower(matches[3])
if mul, ok := uMap[unitPrefix]; ok {
size *= float64(mul)
}
return int64(size), nil
}

165
gosuper/vendor/github.com/docker/go-units/size_test.go generated vendored
View File

@ -1,165 +0,0 @@
package units
import (
"fmt"
"reflect"
"runtime"
"strings"
"testing"
)
func ExampleBytesSize() {
fmt.Println(BytesSize(1024))
fmt.Println(BytesSize(1024 * 1024))
fmt.Println(BytesSize(1048576))
fmt.Println(BytesSize(2 * MiB))
fmt.Println(BytesSize(3.42 * GiB))
fmt.Println(BytesSize(5.372 * TiB))
fmt.Println(BytesSize(2.22 * PiB))
}
func ExampleHumanSize() {
fmt.Println(HumanSize(1000))
fmt.Println(HumanSize(1024))
fmt.Println(HumanSize(1000000))
fmt.Println(HumanSize(1048576))
fmt.Println(HumanSize(2 * MB))
fmt.Println(HumanSize(float64(3.42 * GB)))
fmt.Println(HumanSize(float64(5.372 * TB)))
fmt.Println(HumanSize(float64(2.22 * PB)))
}
func ExampleFromHumanSize() {
fmt.Println(FromHumanSize("32"))
fmt.Println(FromHumanSize("32b"))
fmt.Println(FromHumanSize("32B"))
fmt.Println(FromHumanSize("32k"))
fmt.Println(FromHumanSize("32K"))
fmt.Println(FromHumanSize("32kb"))
fmt.Println(FromHumanSize("32Kb"))
fmt.Println(FromHumanSize("32Mb"))
fmt.Println(FromHumanSize("32Gb"))
fmt.Println(FromHumanSize("32Tb"))
fmt.Println(FromHumanSize("32Pb"))
}
func ExampleRAMInBytes() {
fmt.Println(RAMInBytes("32"))
fmt.Println(RAMInBytes("32b"))
fmt.Println(RAMInBytes("32B"))
fmt.Println(RAMInBytes("32k"))
fmt.Println(RAMInBytes("32K"))
fmt.Println(RAMInBytes("32kb"))
fmt.Println(RAMInBytes("32Kb"))
fmt.Println(RAMInBytes("32Mb"))
fmt.Println(RAMInBytes("32Gb"))
fmt.Println(RAMInBytes("32Tb"))
fmt.Println(RAMInBytes("32Pb"))
fmt.Println(RAMInBytes("32PB"))
fmt.Println(RAMInBytes("32P"))
}
func TestBytesSize(t *testing.T) {
assertEquals(t, "1KiB", BytesSize(1024))
assertEquals(t, "1MiB", BytesSize(1024*1024))
assertEquals(t, "1MiB", BytesSize(1048576))
assertEquals(t, "2MiB", BytesSize(2*MiB))
assertEquals(t, "3.42GiB", BytesSize(3.42*GiB))
assertEquals(t, "5.372TiB", BytesSize(5.372*TiB))
assertEquals(t, "2.22PiB", BytesSize(2.22*PiB))
assertEquals(t, "1.049e+06YiB", BytesSize(KiB*KiB*KiB*KiB*KiB*PiB))
}
func TestHumanSize(t *testing.T) {
assertEquals(t, "1kB", HumanSize(1000))
assertEquals(t, "1.024kB", HumanSize(1024))
assertEquals(t, "1MB", HumanSize(1000000))
assertEquals(t, "1.049MB", HumanSize(1048576))
assertEquals(t, "2MB", HumanSize(2*MB))
assertEquals(t, "3.42GB", HumanSize(float64(3.42*GB)))
assertEquals(t, "5.372TB", HumanSize(float64(5.372*TB)))
assertEquals(t, "2.22PB", HumanSize(float64(2.22*PB)))
assertEquals(t, "1e+04YB", HumanSize(float64(10000000000000*PB)))
}
func TestFromHumanSize(t *testing.T) {
assertSuccessEquals(t, 32, FromHumanSize, "32")
assertSuccessEquals(t, 32, FromHumanSize, "32b")
assertSuccessEquals(t, 32, FromHumanSize, "32B")
assertSuccessEquals(t, 32*KB, FromHumanSize, "32k")
assertSuccessEquals(t, 32*KB, FromHumanSize, "32K")
assertSuccessEquals(t, 32*KB, FromHumanSize, "32kb")
assertSuccessEquals(t, 32*KB, FromHumanSize, "32Kb")
assertSuccessEquals(t, 32*MB, FromHumanSize, "32Mb")
assertSuccessEquals(t, 32*GB, FromHumanSize, "32Gb")
assertSuccessEquals(t, 32*TB, FromHumanSize, "32Tb")
assertSuccessEquals(t, 32*PB, FromHumanSize, "32Pb")
assertSuccessEquals(t, 32.5*KB, FromHumanSize, "32.5kB")
assertSuccessEquals(t, 32.5*KB, FromHumanSize, "32.5 kB")
assertSuccessEquals(t, 32, FromHumanSize, "32.5 B")
assertError(t, FromHumanSize, "")
assertError(t, FromHumanSize, "hello")
assertError(t, FromHumanSize, "-32")
assertError(t, FromHumanSize, ".3kB")
assertError(t, FromHumanSize, " 32 ")
assertError(t, FromHumanSize, "32m b")
assertError(t, FromHumanSize, "32bm")
}
func TestRAMInBytes(t *testing.T) {
assertSuccessEquals(t, 32, RAMInBytes, "32")
assertSuccessEquals(t, 32, RAMInBytes, "32b")
assertSuccessEquals(t, 32, RAMInBytes, "32B")
assertSuccessEquals(t, 32*KiB, RAMInBytes, "32k")
assertSuccessEquals(t, 32*KiB, RAMInBytes, "32K")
assertSuccessEquals(t, 32*KiB, RAMInBytes, "32kb")
assertSuccessEquals(t, 32*KiB, RAMInBytes, "32Kb")
assertSuccessEquals(t, 32*MiB, RAMInBytes, "32Mb")
assertSuccessEquals(t, 32*GiB, RAMInBytes, "32Gb")
assertSuccessEquals(t, 32*TiB, RAMInBytes, "32Tb")
assertSuccessEquals(t, 32*PiB, RAMInBytes, "32Pb")
assertSuccessEquals(t, 32*PiB, RAMInBytes, "32PB")
assertSuccessEquals(t, 32*PiB, RAMInBytes, "32P")
assertSuccessEquals(t, 32, RAMInBytes, "32.3")
tmp := 32.3 * MiB
assertSuccessEquals(t, int64(tmp), RAMInBytes, "32.3 mb")
assertError(t, RAMInBytes, "")
assertError(t, RAMInBytes, "hello")
assertError(t, RAMInBytes, "-32")
assertError(t, RAMInBytes, " 32 ")
assertError(t, RAMInBytes, "32m b")
assertError(t, RAMInBytes, "32bm")
}
func assertEquals(t *testing.T, expected, actual interface{}) {
if expected != actual {
t.Errorf("Expected '%v' but got '%v'", expected, actual)
}
}
// func that maps to the parse function signatures as testing abstraction
type parseFn func(string) (int64, error)
// Define 'String()' for pretty-print
func (fn parseFn) String() string {
fnName := runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name()
return fnName[strings.LastIndex(fnName, ".")+1:]
}
func assertSuccessEquals(t *testing.T, expected int64, fn parseFn, arg string) {
res, err := fn(arg)
if err != nil || res != expected {
t.Errorf("%s(\"%s\") -> expected '%d' but got '%d' with error '%v'", fn, arg, expected, res, err)
}
}
func assertError(t *testing.T, fn parseFn, arg string) {
res, err := fn(arg)
if err == nil && res != -1 {
t.Errorf("%s(\"%s\") -> expected error but got '%d'", fn, arg, res)
}
}

118
gosuper/vendor/github.com/docker/go-units/ulimit.go generated vendored
View File

@ -1,118 +0,0 @@
package units
import (
"fmt"
"strconv"
"strings"
)
// Ulimit is a human friendly version of Rlimit.
type Ulimit struct {
Name string
Hard int64
Soft int64
}
// Rlimit specifies the resource limits, such as max open files.
type Rlimit struct {
Type int `json:"type,omitempty"`
Hard uint64 `json:"hard,omitempty"`
Soft uint64 `json:"soft,omitempty"`
}
const (
// magic numbers for making the syscall
// some of these are defined in the syscall package, but not all.
// Also since Windows client doesn't get access to the syscall package, need to
// define these here
rlimitAs = 9
rlimitCore = 4
rlimitCPU = 0
rlimitData = 2
rlimitFsize = 1
rlimitLocks = 10
rlimitMemlock = 8
rlimitMsgqueue = 12
rlimitNice = 13
rlimitNofile = 7
rlimitNproc = 6
rlimitRss = 5
rlimitRtprio = 14
rlimitRttime = 15
rlimitSigpending = 11
rlimitStack = 3
)
var ulimitNameMapping = map[string]int{
//"as": rlimitAs, // Disabled since this doesn't seem usable with the way Docker inits a container.
"core": rlimitCore,
"cpu": rlimitCPU,
"data": rlimitData,
"fsize": rlimitFsize,
"locks": rlimitLocks,
"memlock": rlimitMemlock,
"msgqueue": rlimitMsgqueue,
"nice": rlimitNice,
"nofile": rlimitNofile,
"nproc": rlimitNproc,
"rss": rlimitRss,
"rtprio": rlimitRtprio,
"rttime": rlimitRttime,
"sigpending": rlimitSigpending,
"stack": rlimitStack,
}
// ParseUlimit parses and returns a Ulimit from the specified string.
func ParseUlimit(val string) (*Ulimit, error) {
parts := strings.SplitN(val, "=", 2)
if len(parts) != 2 {
return nil, fmt.Errorf("invalid ulimit argument: %s", val)
}
if _, exists := ulimitNameMapping[parts[0]]; !exists {
return nil, fmt.Errorf("invalid ulimit type: %s", parts[0])
}
var (
soft int64
hard = &soft // default to soft in case no hard was set
temp int64
err error
)
switch limitVals := strings.Split(parts[1], ":"); len(limitVals) {
case 2:
temp, err = strconv.ParseInt(limitVals[1], 10, 64)
if err != nil {
return nil, err
}
hard = &temp
fallthrough
case 1:
soft, err = strconv.ParseInt(limitVals[0], 10, 64)
if err != nil {
return nil, err
}
default:
return nil, fmt.Errorf("too many limit value arguments - %s, can only have up to two, `soft[:hard]`", parts[1])
}
if soft > *hard {
return nil, fmt.Errorf("ulimit soft limit must be less than or equal to hard limit: %d > %d", soft, *hard)
}
return &Ulimit{Name: parts[0], Soft: soft, Hard: *hard}, nil
}
// GetRlimit returns the RLimit corresponding to Ulimit.
func (u *Ulimit) GetRlimit() (*Rlimit, error) {
t, exists := ulimitNameMapping[u.Name]
if !exists {
return nil, fmt.Errorf("invalid ulimit name %s", u.Name)
}
return &Rlimit{Type: t, Soft: uint64(u.Soft), Hard: uint64(u.Hard)}, nil
}
func (u *Ulimit) String() string {
return fmt.Sprintf("%s=%d:%d", u.Name, u.Soft, u.Hard)
}

131
gosuper/vendor/github.com/docker/go-units/ulimit_test.go generated vendored
View File

@ -1,131 +0,0 @@
package units
import (
"fmt"
"strconv"
"testing"
)
func ExampleParseUlimit() {
fmt.Println(ParseUlimit("nofile=512:1024"))
fmt.Println(ParseUlimit("nofile=1024"))
fmt.Println(ParseUlimit("cpu=2:4"))
fmt.Println(ParseUlimit("cpu=6"))
}
func TestParseUlimitValid(t *testing.T) {
u1 := &Ulimit{"nofile", 1024, 512}
if u2, _ := ParseUlimit("nofile=512:1024"); *u1 != *u2 {
t.Fatalf("expected %q, but got %q", u1, u2)
}
}
func TestParseUlimitInvalidLimitType(t *testing.T) {
if _, err := ParseUlimit("notarealtype=1024:1024"); err == nil {
t.Fatalf("expected error on invalid ulimit type")
}
}
func TestParseUlimitBadFormat(t *testing.T) {
if _, err := ParseUlimit("nofile:1024:1024"); err == nil {
t.Fatal("expected error on bad syntax")
}
if _, err := ParseUlimit("nofile"); err == nil {
t.Fatal("expected error on bad syntax")
}
if _, err := ParseUlimit("nofile="); err == nil {
t.Fatal("expected error on bad syntax")
}
if _, err := ParseUlimit("nofile=:"); err == nil {
t.Fatal("expected error on bad syntax")
}
if _, err := ParseUlimit("nofile=:1024"); err == nil {
t.Fatal("expected error on bad syntax")
}
}
func TestParseUlimitHardLessThanSoft(t *testing.T) {
if _, err := ParseUlimit("nofile=1024:1"); err == nil {
t.Fatal("expected error on hard limit less than soft limit")
}
}
func TestParseUlimitInvalidValueType(t *testing.T) {
if _, err := ParseUlimit("nofile=asdf"); err == nil {
t.Fatal("expected error on bad value type, but got no error")
} else if _, ok := err.(*strconv.NumError); !ok {
t.Fatalf("expected error on bad value type, but got `%s`", err)
}
if _, err := ParseUlimit("nofile=1024:asdf"); err == nil {
t.Fatal("expected error on bad value type, but got no error")
} else if _, ok := err.(*strconv.NumError); !ok {
t.Fatalf("expected error on bad value type, but got `%s`", err)
}
}
func TestParseUlimitTooManyValueArgs(t *testing.T) {
if _, err := ParseUlimit("nofile=1024:1:50"); err == nil {
t.Fatalf("expected error on more than two value arguments")
}
}
func TestUlimitStringOutput(t *testing.T) {
u := &Ulimit{"nofile", 1024, 512}
if s := u.String(); s != "nofile=512:1024" {
t.Fatal("expected String to return nofile=512:1024, but got", s)
}
}
func TestGetRlimit(t *testing.T) {
tt := []struct {
ulimit Ulimit
rlimit Rlimit
}{
{Ulimit{"core", 10, 12}, Rlimit{rlimitCore, 10, 12}},
{Ulimit{"cpu", 1, 10}, Rlimit{rlimitCPU, 1, 10}},
{Ulimit{"data", 5, 0}, Rlimit{rlimitData, 5, 0}},
{Ulimit{"fsize", 2, 2}, Rlimit{rlimitFsize, 2, 2}},
{Ulimit{"locks", 0, 0}, Rlimit{rlimitLocks, 0, 0}},
{Ulimit{"memlock", 10, 10}, Rlimit{rlimitMemlock, 10, 10}},
{Ulimit{"msgqueue", 9, 1}, Rlimit{rlimitMsgqueue, 9, 1}},
{Ulimit{"nice", 9, 9}, Rlimit{rlimitNice, 9, 9}},
{Ulimit{"nofile", 4, 100}, Rlimit{rlimitNofile, 4, 100}},
{Ulimit{"nproc", 5, 5}, Rlimit{rlimitNproc, 5, 5}},
{Ulimit{"rss", 0, 5}, Rlimit{rlimitRss, 0, 5}},
{Ulimit{"rtprio", 100, 65}, Rlimit{rlimitRtprio, 100, 65}},
{Ulimit{"rttime", 55, 102}, Rlimit{rlimitRttime, 55, 102}},
{Ulimit{"sigpending", 14, 20}, Rlimit{rlimitSigpending, 14, 20}},
{Ulimit{"stack", 1, 1}, Rlimit{rlimitStack, 1, 1}},
}
for _, te := range tt {
res, err := te.ulimit.GetRlimit()
if err != nil {
t.Errorf("expected not to fail: %s", err)
}
if res.Type != te.rlimit.Type {
t.Errorf("expected Type to be %d but got %d",
te.rlimit.Type, res.Type)
}
if res.Soft != te.rlimit.Soft {
t.Errorf("expected Soft to be %d but got %d",
te.rlimit.Soft, res.Soft)
}
if res.Hard != te.rlimit.Hard {
t.Errorf("expected Hard to be %d but got %d",
te.rlimit.Hard, res.Hard)
}
}
}
func TestGetRlimitBadUlimitName(t *testing.T) {
name := "bla"
uLimit := Ulimit{name, 0, 0}
if _, err := uLimit.GetRlimit(); err == nil {
t.Error("expected error on bad Ulimit name")
}
}

9
gosuper/vendor/github.com/go-ole/go-ole/.travis.yml generated vendored
View File

@ -1,9 +0,0 @@
language: go
sudo: false
go:
- 1.1
- 1.2
- 1.3
- 1.4
- tip

49
gosuper/vendor/github.com/go-ole/go-ole/ChangeLog.md generated vendored
View File

@ -1,49 +0,0 @@
# Version 1.x.x
* **Add more test cases and reference new test COM server project.** (Placeholder for future additions)
# Version 1.2.0-alphaX
**Minimum supported version is now Go 1.4. Go 1.1 support is deprecated, but should still build.**
* Added CI configuration for Travis-CI and AppVeyor.
* Added test InterfaceID and ClassID for the COM Test Server project.
* Added more inline documentation (#83).
* Added IEnumVARIANT implementation (#88).
* Added IEnumVARIANT test cases (#99, #100, #101).
* Added support for retrieving `time.Time` from VARIANT (#92).
* Added test case for IUnknown (#64).
* Added test case for IDispatch (#64).
* Added test cases for scalar variants (#64, #76).
# Version 1.1.1
* Fixes for Linux build.
* Fixes for Windows build.
# Version 1.1.0
The change to provide building on all platforms is a new feature. The increase in minor version reflects that and allows those who wish to stay on 1.0.x to continue to do so. Support for 1.0.x will be limited to bug fixes.
* Move GUID out of variables.go into its own file to make new documentation available.
* Move OleError out of ole.go into its own file to make new documentation available.
* Add documentation to utility functions.
* Add documentation to variant receiver functions.
* Add documentation to ole structures.
* Make variant available to other systems outside of Windows.
* Make OLE structures available to other systems outside of Windows.
## New Features
* Library should now be built on all platforms supported by Go. Library will NOOP on any platform that is not Windows.
* More functions are now documented and available on godoc.org.
# Version 1.0.1
1. Fix package references from repository location change.
# Version 1.0.0
This version is stable enough for use. The COM API is still incomplete, but provides enough functionality for accessing COM servers using IDispatch interface.
There is no changelog for this version. Check commits for history.

46
gosuper/vendor/github.com/go-ole/go-ole/README.md generated vendored
View File

@ -1,46 +0,0 @@
#Go OLE
[![Build status](https://ci.appveyor.com/api/projects/status/qr0u2sf7q43us9fj?svg=true)](https://ci.appveyor.com/project/jacobsantos/go-ole-jgs28)
[![Build Status](https://travis-ci.org/go-ole/go-ole.svg?branch=master)](https://travis-ci.org/go-ole/go-ole)
[![GoDoc](https://godoc.org/github.com/go-ole/go-ole?status.svg)](https://godoc.org/github.com/go-ole/go-ole)
Go bindings for Windows COM using shared libraries instead of cgo.
By Yasuhiro Matsumoto.
## Install
To experiment with go-ole, you can just compile and run the example program:
```
go get github.com/go-ole/go-ole
cd /path/to/go-ole/
go test
cd /path/to/go-ole/example/excel
go run excel.go
```
## Continuous Integration
Continuous integration configuration has been added for both Travis-CI and AppVeyor. You will have to add these to your own account for your fork in order for it to run.
**Travis-CI**
Travis-CI was added to check builds on Linux to ensure that `go get` works when cross building. Currently, Travis-CI is not used to test cross-building, but this may be changed in the future. It is also not currently possible to test the library on Linux, since COM API is specific to Windows and it is not currently possible to run a COM server on Linux or even connect to a remote COM server.
**AppVeyor**
AppVeyor is used to build on Windows using the (in-development) test COM server. It is currently only used to test the build and ensure that the code works on Windows. It will be used to register a COM server and then run the test cases based on the test COM server.
The tests currently do run and do pass and this should be maintained with commits.
##Versioning
Go OLE uses [semantic versioning](http://semver.org) for version numbers, which is similar to the version contract of the Go language. Which means that the major version will always maintain backwards compatibility with minor versions. Minor versions will only add new additions and changes. Fixes will always be in patch.
This contract should allow you to upgrade to new minor and patch versions without breakage or modifications to your existing code. Leave a ticket, if there is breakage, so that it could be fixed.
##LICENSE
Under the MIT License: http://mattn.mit-license.org/2013

63
gosuper/vendor/github.com/go-ole/go-ole/appveyor.yml generated vendored
View File

@ -1,63 +0,0 @@
# Notes:
# - Minimal appveyor.yml file is an empty file. All sections are optional.
# - Indent each level of configuration with 2 spaces. Do not use tabs!
# - All section names are case-sensitive.
# - Section names should be unique on each level.
version: "1.3.0.{build}-alpha-{branch}"
os: Windows Server 2012 R2
branches:
only:
- master
- v1.2
- v1.1
- v1.0
skip_tags: true
clone_folder: c:\gopath\src\github.com\go-ole\go-ole
environment:
GOPATH: c:\gopath
matrix:
- GOARCH: amd64
GOVERSION: 1.4
GOROOT: c:\go
DOWNLOADPLATFORM: "x64"
install:
- choco install mingw
- SET PATH=c:\tools\mingw64\bin;%PATH%
# - Download COM Server
- ps: Start-FileDownload "https://github.com/go-ole/test-com-server/releases/download/v1.0.2/test-com-server-${env:DOWNLOADPLATFORM}.zip"
- 7z e test-com-server-%DOWNLOADPLATFORM%.zip -oc:\gopath\src\github.com\go-ole\go-ole > NUL
- c:\gopath\src\github.com\go-ole\go-ole\build\register-assembly.bat
# - set
- go version
- go env
- c:\gopath\src\github.com\go-ole\go-ole\build\compile-go.bat
- go tool dist install -v cmd/8a
- go tool dist install -v cmd/8c
- go tool dist install -v cmd/8g
- go tool dist install -v cmd/8l
- go tool dist install -v cmd/6a
- go tool dist install -v cmd/6c
- go tool dist install -v cmd/6g
- go tool dist install -v cmd/6l
- go get -u golang.org/x/tools/cmd/cover
- go get -u golang.org/x/tools/cmd/godoc
- go get -u golang.org/x/tools/cmd/stringer
build_script:
- cd c:\gopath\src\github.com\go-ole\go-ole
- go get -v -t ./...
- go build
- go test -v -cover ./...
# disable automatic tests
test: off
# disable deployment
deploy: off

5
gosuper/vendor/github.com/go-ole/go-ole/build/compile-go.bat generated vendored
View File

@ -1,5 +0,0 @@
@echo OFF
echo "BUILD GOLANG"
cd "%GOROOT%\src"
./make.bat --dist-tool

8
gosuper/vendor/github.com/go-ole/go-ole/build/register-assembly.bat generated vendored
View File

@ -1,8 +0,0 @@
@ECHO OFF
IF "x86" == "%DOWNLOADPLATFORM%" (
CALL c:\Windows\Microsoft.NET\Framework\v4.0.30319\RegAsm.exe /codebase /nologo c:\gopath\src\github.com\go-ole\go-ole\TestCOMServer.dll
)
IF "x64" == "%DOWNLOADPLATFORM%" (
CALL c:\Windows\Microsoft.NET\Framework64\v4.0.30319\RegAsm.exe /codebase /nologo c:\gopath\src\github.com\go-ole\go-ole\TestCOMServer.dll
)

329
gosuper/vendor/github.com/go-ole/go-ole/com.go generated vendored
View File

@ -1,329 +0,0 @@
// +build windows
package ole
import (
"errors"
"syscall"
"time"
"unicode/utf16"
"unsafe"
)
var (
procCoInitialize, _ = modole32.FindProc("CoInitialize")
procCoInitializeEx, _ = modole32.FindProc("CoInitializeEx")
procCoUninitialize, _ = modole32.FindProc("CoUninitialize")
procCoCreateInstance, _ = modole32.FindProc("CoCreateInstance")
procCoTaskMemFree, _ = modole32.FindProc("CoTaskMemFree")
procCLSIDFromProgID, _ = modole32.FindProc("CLSIDFromProgID")
procCLSIDFromString, _ = modole32.FindProc("CLSIDFromString")
procStringFromCLSID, _ = modole32.FindProc("StringFromCLSID")
procStringFromIID, _ = modole32.FindProc("StringFromIID")
procIIDFromString, _ = modole32.FindProc("IIDFromString")
procGetUserDefaultLCID, _ = modkernel32.FindProc("GetUserDefaultLCID")
procCopyMemory, _ = modkernel32.FindProc("RtlMoveMemory")
procVariantInit, _ = modoleaut32.FindProc("VariantInit")
procVariantClear, _ = modoleaut32.FindProc("VariantClear")
procVariantTimeToSystemTime, _ = modoleaut32.FindProc("VariantTimeToSystemTime")
procSysAllocString, _ = modoleaut32.FindProc("SysAllocString")
procSysAllocStringLen, _ = modoleaut32.FindProc("SysAllocStringLen")
procSysFreeString, _ = modoleaut32.FindProc("SysFreeString")
procSysStringLen, _ = modoleaut32.FindProc("SysStringLen")
procCreateDispTypeInfo, _ = modoleaut32.FindProc("CreateDispTypeInfo")
procCreateStdDispatch, _ = modoleaut32.FindProc("CreateStdDispatch")
procGetActiveObject, _ = modoleaut32.FindProc("GetActiveObject")
procGetMessageW, _ = moduser32.FindProc("GetMessageW")
procDispatchMessageW, _ = moduser32.FindProc("DispatchMessageW")
)
// coInitialize initializes COM library on current thread.
//
// MSDN documentation suggests that this function should not be called. Call
// CoInitializeEx() instead. The reason has to do with threading and this
// function is only for single-threaded apartments.
//
// That said, most users of the library have gotten away with just this
// function. If you are experiencing threading issues, then use
// CoInitializeEx().
func coInitialize() (err error) {
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms678543(v=vs.85).aspx
// Suggests that no value should be passed to CoInitialized.
// Could just be Call() since the parameter is optional. <-- Needs testing to be sure.
hr, _, _ := procCoInitialize.Call(uintptr(0))
if hr != 0 {
err = NewError(hr)
}
return
}
// coInitializeEx initializes COM library with concurrency model.
func coInitializeEx(coinit uint32) (err error) {
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms695279(v=vs.85).aspx
// Suggests that the first parameter is not only optional but should always be NULL.
hr, _, _ := procCoInitializeEx.Call(uintptr(0), uintptr(coinit))
if hr != 0 {
err = NewError(hr)
}
return
}
// CoInitialize initializes COM library on current thread.
//
// MSDN documentation suggests that this function should not be called. Call
// CoInitializeEx() instead. The reason has to do with threading and this
// function is only for single-threaded apartments.
//
// That said, most users of the library have gotten away with just this
// function. If you are experiencing threading issues, then use
// CoInitializeEx().
func CoInitialize(p uintptr) (err error) {
// p is ignored and won't be used.
// Avoid any variable not used errors.
p = uintptr(0)
return coInitialize()
}
// CoInitializeEx initializes COM library with concurrency model.
func CoInitializeEx(p uintptr, coinit uint32) (err error) {
// Avoid any variable not used errors.
p = uintptr(0)
return coInitializeEx(coinit)
}
// CoUninitialize uninitializes COM Library.
func CoUninitialize() {
procCoUninitialize.Call()
}
// CoTaskMemFree frees memory pointer.
func CoTaskMemFree(memptr uintptr) {
procCoTaskMemFree.Call(memptr)
}
// CLSIDFromProgID retrieves Class Identifier with the given Program Identifier.
//
// The Programmatic Identifier must be registered, because it will be looked up
// in the Windows Registry. The registry entry has the following keys: CLSID,
// Insertable, Protocol and Shell
// (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx).
//
// programID identifies the class id with less precision and is not guaranteed
// to be unique. These are usually found in the registry under
// HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of
// "Program.Component.Version" with version being optional.
//
// CLSIDFromProgID in Windows API.
func CLSIDFromProgID(progId string) (clsid *GUID, err error) {
var guid GUID
lpszProgID := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId)))
hr, _, _ := procCLSIDFromProgID.Call(lpszProgID, uintptr(unsafe.Pointer(&guid)))
if hr != 0 {
err = NewError(hr)
}
clsid = &guid
return
}
// CLSIDFromString retrieves Class ID from string representation.
//
// This is technically the string version of the GUID and will convert the
// string to object.
//
// CLSIDFromString in Windows API.
func CLSIDFromString(str string) (clsid *GUID, err error) {
var guid GUID
lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(str)))
hr, _, _ := procCLSIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
if hr != 0 {
err = NewError(hr)
}
clsid = &guid
return
}
// StringFromCLSID returns GUID formated string from GUID object.
func StringFromCLSID(clsid *GUID) (str string, err error) {
var p *uint16
hr, _, _ := procStringFromCLSID.Call(uintptr(unsafe.Pointer(clsid)), uintptr(unsafe.Pointer(&p)))
if hr != 0 {
err = NewError(hr)
}
str = LpOleStrToString(p)
return
}
// IIDFromString returns GUID from program ID.
func IIDFromString(progId string) (clsid *GUID, err error) {
var guid GUID
lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId)))
hr, _, _ := procIIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
if hr != 0 {
err = NewError(hr)
}
clsid = &guid
return
}
// StringFromIID returns GUID formatted string from GUID object.
func StringFromIID(iid *GUID) (str string, err error) {
var p *uint16
hr, _, _ := procStringFromIID.Call(uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&p)))
if hr != 0 {
err = NewError(hr)
}
str = LpOleStrToString(p)
return
}
// CreateInstance of single uninitialized object with GUID.
func CreateInstance(clsid *GUID, iid *GUID) (unk *IUnknown, err error) {
if iid == nil {
iid = IID_IUnknown
}
hr, _, _ := procCoCreateInstance.Call(
uintptr(unsafe.Pointer(clsid)),
0,
CLSCTX_SERVER,
uintptr(unsafe.Pointer(iid)),
uintptr(unsafe.Pointer(&unk)))
if hr != 0 {
err = NewError(hr)
}
return
}
// GetActiveObject retrieves pointer to active object.
func GetActiveObject(clsid *GUID, iid *GUID) (unk *IUnknown, err error) {
if iid == nil {
iid = IID_IUnknown
}
hr, _, _ := procGetActiveObject.Call(
uintptr(unsafe.Pointer(clsid)),
uintptr(unsafe.Pointer(iid)),
uintptr(unsafe.Pointer(&unk)))
if hr != 0 {
err = NewError(hr)
}
return
}
// VariantInit initializes variant.
func VariantInit(v *VARIANT) (err error) {
hr, _, _ := procVariantInit.Call(uintptr(unsafe.Pointer(v)))
if hr != 0 {
err = NewError(hr)
}
return
}
// VariantClear clears value in Variant settings to VT_EMPTY.
func VariantClear(v *VARIANT) (err error) {
hr, _, _ := procVariantClear.Call(uintptr(unsafe.Pointer(v)))
if hr != 0 {
err = NewError(hr)
}
return
}
// SysAllocString allocates memory for string and copies string into memory.
func SysAllocString(v string) (ss *int16) {
pss, _, _ := procSysAllocString.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(v))))
ss = (*int16)(unsafe.Pointer(pss))
return
}
// SysAllocStringLen copies up to length of given string returning pointer.
func SysAllocStringLen(v string) (ss *int16) {
utf16 := utf16.Encode([]rune(v + "\x00"))
ptr := &utf16[0]
pss, _, _ := procSysAllocStringLen.Call(uintptr(unsafe.Pointer(ptr)), uintptr(len(utf16)-1))
ss = (*int16)(unsafe.Pointer(pss))
return
}
// SysFreeString frees string system memory. This must be called with SysAllocString.
func SysFreeString(v *int16) (err error) {
hr, _, _ := procSysFreeString.Call(uintptr(unsafe.Pointer(v)))
if hr != 0 {
err = NewError(hr)
}
return
}
// SysStringLen is the length of the system allocated string.
func SysStringLen(v *int16) uint32 {
l, _, _ := procSysStringLen.Call(uintptr(unsafe.Pointer(v)))
return uint32(l)
}
// CreateStdDispatch provides default IDispatch implementation for IUnknown.
//
// This handles default IDispatch implementation for objects. It haves a few
// limitations with only supporting one language. It will also only return
// default exception codes.
func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (disp *IDispatch, err error) {
hr, _, _ := procCreateStdDispatch.Call(
uintptr(unsafe.Pointer(unk)),
v,
uintptr(unsafe.Pointer(ptinfo)),
uintptr(unsafe.Pointer(&disp)))
if hr != 0 {
err = NewError(hr)
}
return
}
// CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch.
//
// This will not handle the full implementation of the interface.
func CreateDispTypeInfo(idata *INTERFACEDATA) (pptinfo *IUnknown, err error) {
hr, _, _ := procCreateDispTypeInfo.Call(
uintptr(unsafe.Pointer(idata)),
uintptr(GetUserDefaultLCID()),
uintptr(unsafe.Pointer(&pptinfo)))
if hr != 0 {
err = NewError(hr)
}
return
}
// copyMemory moves location of a block of memory.
func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {
procCopyMemory.Call(uintptr(dest), uintptr(src), uintptr(length))
}
// GetUserDefaultLCID retrieves current user default locale.
func GetUserDefaultLCID() (lcid uint32) {
ret, _, _ := procGetUserDefaultLCID.Call()
lcid = uint32(ret)
return
}
// GetMessage in message queue from runtime.
//
// This function appears to block. PeekMessage does not block.
func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, err error) {
r0, _, err := procGetMessageW.Call(uintptr(unsafe.Pointer(msg)), uintptr(hwnd), uintptr(MsgFilterMin), uintptr(MsgFilterMax))
ret = int32(r0)
return
}
// DispatchMessage to window procedure.
func DispatchMessage(msg *Msg) (ret int32) {
r0, _, _ := procDispatchMessageW.Call(uintptr(unsafe.Pointer(msg)))
ret = int32(r0)
return
}
// GetVariantDate converts COM Variant Time value to Go time.Time.
func GetVariantDate(value float64) (time.Time, error) {
var st syscall.Systemtime
r, _, _ := procVariantTimeToSystemTime.Call(uintptr(unsafe.Pointer(&value)), uintptr(unsafe.Pointer(&st)))
if r != 0 {
return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), nil), nil
}
return time.Now(), errors.New("Could not convert to time, passing current time.")
}

174
gosuper/vendor/github.com/go-ole/go-ole/com_func.go generated vendored
View File

@ -1,174 +0,0 @@
// +build !windows
package ole
import (
"time"
"unsafe"
)
// coInitialize initializes COM library on current thread.
//
// MSDN documentation suggests that this function should not be called. Call
// CoInitializeEx() instead. The reason has to do with threading and this
// function is only for single-threaded apartments.
//
// That said, most users of the library have gotten away with just this
// function. If you are experiencing threading issues, then use
// CoInitializeEx().
func coInitialize() error {
return NewError(E_NOTIMPL)
}
// coInitializeEx initializes COM library with concurrency model.
func coInitializeEx(coinit uint32) error {
return NewError(E_NOTIMPL)
}
// CoInitialize initializes COM library on current thread.
//
// MSDN documentation suggests that this function should not be called. Call
// CoInitializeEx() instead. The reason has to do with threading and this
// function is only for single-threaded apartments.
//
// That said, most users of the library have gotten away with just this
// function. If you are experiencing threading issues, then use
// CoInitializeEx().
func CoInitialize(p uintptr) error {
return NewError(E_NOTIMPL)
}
// CoInitializeEx initializes COM library with concurrency model.
func CoInitializeEx(p uintptr, coinit uint32) error {
return NewError(E_NOTIMPL)
}
// CoUninitialize uninitializes COM Library.
func CoUninitialize() {}
// CoTaskMemFree frees memory pointer.
func CoTaskMemFree(memptr uintptr) {}
// CLSIDFromProgID retrieves Class Identifier with the given Program Identifier.
//
// The Programmatic Identifier must be registered, because it will be looked up
// in the Windows Registry. The registry entry has the following keys: CLSID,
// Insertable, Protocol and Shell
// (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx).
//
// programID identifies the class id with less precision and is not guaranteed
// to be unique. These are usually found in the registry under
// HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of
// "Program.Component.Version" with version being optional.
//
// CLSIDFromProgID in Windows API.
func CLSIDFromProgID(progId string) (*GUID, error) {
return nil, NewError(E_NOTIMPL)
}
// CLSIDFromString retrieves Class ID from string representation.
//
// This is technically the string version of the GUID and will convert the
// string to object.
//
// CLSIDFromString in Windows API.
func CLSIDFromString(str string) (*GUID, error) {
return nil, NewError(E_NOTIMPL)
}
// StringFromCLSID returns GUID formated string from GUID object.
func StringFromCLSID(clsid *GUID) (string, error) {
return "", NewError(E_NOTIMPL)
}
// IIDFromString returns GUID from program ID.
func IIDFromString(progId string) (*GUID, error) {
return nil, NewError(E_NOTIMPL)
}
// StringFromIID returns GUID formatted string from GUID object.
func StringFromIID(iid *GUID) (string, error) {
return "", NewError(E_NOTIMPL)
}
// CreateInstance of single uninitialized object with GUID.
func CreateInstance(clsid *GUID, iid *GUID) (*IUnknown, error) {
return nil, NewError(E_NOTIMPL)
}
// GetActiveObject retrieves pointer to active object.
func GetActiveObject(clsid *GUID, iid *GUID) (*IUnknown, error) {
return nil, NewError(E_NOTIMPL)
}
// VariantInit initializes variant.
func VariantInit(v *VARIANT) error {
return NewError(E_NOTIMPL)
}
// VariantClear clears value in Variant settings to VT_EMPTY.
func VariantClear(v *VARIANT) error {
return NewError(E_NOTIMPL)
}
// SysAllocString allocates memory for string and copies string into memory.
func SysAllocString(v string) *int16 {
u := int16(0)
return &u
}
// SysAllocStringLen copies up to length of given string returning pointer.
func SysAllocStringLen(v string) *int16 {
u := int16(0)
return &u
}
// SysFreeString frees string system memory. This must be called with SysAllocString.
func SysFreeString(v *int16) error {
return NewError(E_NOTIMPL)
}
// SysStringLen is the length of the system allocated string.
func SysStringLen(v *int16) uint32 {
return uint32(0)
}
// CreateStdDispatch provides default IDispatch implementation for IUnknown.
//
// This handles default IDispatch implementation for objects. It haves a few
// limitations with only supporting one language. It will also only return
// default exception codes.
func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (*IDispatch, error) {
return nil, NewError(E_NOTIMPL)
}
// CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch.
//
// This will not handle the full implementation of the interface.
func CreateDispTypeInfo(idata *INTERFACEDATA) (*IUnknown, error) {
return nil, NewError(E_NOTIMPL)
}
// copyMemory moves location of a block of memory.
func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {}
// GetUserDefaultLCID retrieves current user default locale.
func GetUserDefaultLCID() uint32 {
return uint32(0)
}
// GetMessage in message queue from runtime.
//
// This function appears to block. PeekMessage does not block.
func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (int32, error) {
return int32(0), NewError(E_NOTIMPL)
}
// DispatchMessage to window procedure.
func DispatchMessage(msg *Msg) int32 {
return int32(0)
}
func GetVariantDate(value float64) (time.Time, error) {
return time.Now(), NewError(E_NOTIMPL)
}

193
gosuper/vendor/github.com/go-ole/go-ole/com_func_test.go generated vendored
View File

@ -1,193 +0,0 @@
// +build !windows
package ole
import "testing"
// TestComSetupAndShutDown tests that API fails on Linux.
func TestComSetupAndShutDown(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := coInitialize()
if err == nil {
t.Error("should be error, because only Windows is supported.")
t.FailNow()
}
CoUninitialize()
}
// TestComPublicSetupAndShutDown tests that API fails on Linux.
func TestComPublicSetupAndShutDown(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := CoInitialize(0)
if err == nil {
t.Error("should be error, because only Windows is supported.")
t.FailNow()
}
CoUninitialize()
}
// TestComPublicSetupAndShutDown_WithValue tests that API fails on Linux.
func TestComPublicSetupAndShutDown_WithValue(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := CoInitialize(5)
if err == nil {
t.Error("should be error, because only Windows is supported.")
t.FailNow()
}
CoUninitialize()
}
// TestComExSetupAndShutDown tests that API fails on Linux.
func TestComExSetupAndShutDown(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := coInitializeEx(COINIT_MULTITHREADED)
if err == nil {
t.Error("should be error, because only Windows is supported.")
t.FailNow()
}
CoUninitialize()
}
// TestComPublicExSetupAndShutDown tests that API fails on Linux.
func TestComPublicExSetupAndShutDown(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := CoInitializeEx(0, COINIT_MULTITHREADED)
if err == nil {
t.Error("should be error, because only Windows is supported.")
t.FailNow()
}
CoUninitialize()
}
// TestComPublicExSetupAndShutDown_WithValue tests that API fails on Linux.
func TestComPublicExSetupAndShutDown_WithValue(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := CoInitializeEx(5, COINIT_MULTITHREADED)
if err == nil {
t.Error("should be error, because only Windows is supported.")
t.FailNow()
}
CoUninitialize()
}
// TestClsidFromProgID_WindowsMediaNSSManager tests that API fails on Linux.
func TestClsidFromProgID_WindowsMediaNSSManager(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
coInitialize()
defer CoUninitialize()
_, err := CLSIDFromProgID("WMPNSSCI.NSSManager")
if err == nil {
t.Error("should be error, because only Windows is supported.")
t.FailNow()
}
}
// TestClsidFromString_WindowsMediaNSSManager tests that API fails on Linux.
func TestClsidFromString_WindowsMediaNSSManager(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
coInitialize()
defer CoUninitialize()
_, err := CLSIDFromString("{92498132-4D1A-4297-9B78-9E2E4BA99C07}")
if err == nil {
t.Error("should be error, because only Windows is supported.")
t.FailNow()
}
}
// TestCreateInstance_WindowsMediaNSSManager tests that API fails on Linux.
func TestCreateInstance_WindowsMediaNSSManager(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
coInitialize()
defer CoUninitialize()
_, err := CLSIDFromProgID("WMPNSSCI.NSSManager")
if err == nil {
t.Error("should be error, because only Windows is supported.")
t.FailNow()
}
}
// TestError tests that API fails on Linux.
func TestError(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
coInitialize()
defer CoUninitialize()
_, err := CLSIDFromProgID("INTERFACE-NOT-FOUND")
if err == nil {
t.Error("should be error, because only Windows is supported.")
t.FailNow()
}
switch vt := err.(type) {
case *OleError:
default:
t.Fatalf("should be *ole.OleError %t", vt)
}
}

205
gosuper/vendor/github.com/go-ole/go-ole/com_test.go generated vendored
View File

@ -1,205 +0,0 @@
// +build windows
package ole
import (
"fmt"
"testing"
)
func TestComSetupAndShutDown(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := coInitialize()
if err != nil {
t.Error(err)
t.FailNow()
}
CoUninitialize()
}
func TestComPublicSetupAndShutDown(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := CoInitialize(0)
if err != nil {
t.Error(err)
t.FailNow()
}
CoUninitialize()
}
func TestComPublicSetupAndShutDown_WithValue(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := CoInitialize(5)
if err != nil {
t.Error(err)
t.FailNow()
}
CoUninitialize()
}
func TestComExSetupAndShutDown(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := coInitializeEx(COINIT_MULTITHREADED)
if err != nil {
t.Error(err)
t.FailNow()
}
CoUninitialize()
}
func TestComPublicExSetupAndShutDown(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := CoInitializeEx(0, COINIT_MULTITHREADED)
if err != nil {
t.Error(err)
t.FailNow()
}
CoUninitialize()
}
func TestComPublicExSetupAndShutDown_WithValue(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
err := CoInitializeEx(5, COINIT_MULTITHREADED)
if err != nil {
t.Error(err)
t.FailNow()
}
CoUninitialize()
}
func TestClsidFromProgID_WindowsMediaNSSManager(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
expected := &GUID{0x92498132, 0x4D1A, 0x4297, [8]byte{0x9B, 0x78, 0x9E, 0x2E, 0x4B, 0xA9, 0x9C, 0x07}}
coInitialize()
defer CoUninitialize()
actual, err := CLSIDFromProgID("WMPNSSCI.NSSManager")
if err == nil {
if !IsEqualGUID(expected, actual) {
t.Log(err)
t.Log(fmt.Sprintf("Actual GUID: %+v\n", actual))
t.Fail()
}
}
}
func TestClsidFromString_WindowsMediaNSSManager(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
expected := &GUID{0x92498132, 0x4D1A, 0x4297, [8]byte{0x9B, 0x78, 0x9E, 0x2E, 0x4B, 0xA9, 0x9C, 0x07}}
coInitialize()
defer CoUninitialize()
actual, err := CLSIDFromString("{92498132-4D1A-4297-9B78-9E2E4BA99C07}")
if !IsEqualGUID(expected, actual) {
t.Log(err)
t.Log(fmt.Sprintf("Actual GUID: %+v\n", actual))
t.Fail()
}
}
func TestCreateInstance_WindowsMediaNSSManager(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
expected := &GUID{0x92498132, 0x4D1A, 0x4297, [8]byte{0x9B, 0x78, 0x9E, 0x2E, 0x4B, 0xA9, 0x9C, 0x07}}
coInitialize()
defer CoUninitialize()
actual, err := CLSIDFromProgID("WMPNSSCI.NSSManager")
if err == nil {
if !IsEqualGUID(expected, actual) {
t.Log(err)
t.Log(fmt.Sprintf("Actual GUID: %+v\n", actual))
t.Fail()
}
unknown, err := CreateInstance(actual, IID_IUnknown)
if err != nil {
t.Log(err)
t.Fail()
}
unknown.Release()
}
}
func TestError(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Log(r)
t.Fail()
}
}()
coInitialize()
defer CoUninitialize()
_, err := CLSIDFromProgID("INTERFACE-NOT-FOUND")
if err == nil {
t.Fatalf("should be fail", err)
}
switch vt := err.(type) {
case *OleError:
default:
t.Fatalf("should be *ole.OleError %t", vt)
}
}

192
gosuper/vendor/github.com/go-ole/go-ole/connect.go generated vendored
View File

@ -1,192 +0,0 @@
package ole
// Connection contains IUnknown for fluent interface interaction.
//
// Deprecated. Use oleutil package instead.
type Connection struct {
Object *IUnknown // Access COM
}
// Initialize COM.
func (*Connection) Initialize() (err error) {
return coInitialize()
}
// Uninitialize COM.
func (*Connection) Uninitialize() {
CoUninitialize()
}
// Create IUnknown object based first on ProgId and then from String.
func (c *Connection) Create(progId string) (err error) {
var clsid *GUID
clsid, err = CLSIDFromProgID(progId)
if err != nil {
clsid, err = CLSIDFromString(progId)
if err != nil {
return
}
}
unknown, err := CreateInstance(clsid, IID_IUnknown)
if err != nil {
return
}
c.Object = unknown
return
}
// Release IUnknown object.
func (c *Connection) Release() {
c.Object.Release()
}
// Load COM object from list of programIDs or strings.
func (c *Connection) Load(names ...string) (errors []error) {
var tempErrors []error = make([]error, len(names))
var numErrors int = 0
for _, name := range names {
err := c.Create(name)
if err != nil {
tempErrors = append(tempErrors, err)
numErrors += 1
continue
}
break
}
copy(errors, tempErrors[0:numErrors])
return
}
// Dispatch returns Dispatch object.
func (c *Connection) Dispatch() (object *Dispatch, err error) {
dispatch, err := c.Object.QueryInterface(IID_IDispatch)
if err != nil {
return
}
object = &Dispatch{dispatch}
return
}
// Dispatch stores IDispatch object.
type Dispatch struct {
Object *IDispatch // Dispatch object.
}
// Call method on IDispatch with parameters.
func (d *Dispatch) Call(method string, params ...interface{}) (result *VARIANT, err error) {
id, err := d.GetId(method)
if err != nil {
return
}
result, err = d.Invoke(id, DISPATCH_METHOD, params)
return
}
// MustCall method on IDispatch with parameters.
func (d *Dispatch) MustCall(method string, params ...interface{}) (result *VARIANT) {
id, err := d.GetId(method)
if err != nil {
panic(err)
}
result, err = d.Invoke(id, DISPATCH_METHOD, params)
if err != nil {
panic(err)
}
return
}
// Get property on IDispatch with parameters.
func (d *Dispatch) Get(name string, params ...interface{}) (result *VARIANT, err error) {
id, err := d.GetId(name)
if err != nil {
return
}
result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
return
}
// MustGet property on IDispatch with parameters.
func (d *Dispatch) MustGet(name string, params ...interface{}) (result *VARIANT) {
id, err := d.GetId(name)
if err != nil {
panic(err)
}
result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
if err != nil {
panic(err)
}
return
}
// Set property on IDispatch with parameters.
func (d *Dispatch) Set(name string, params ...interface{}) (result *VARIANT, err error) {
id, err := d.GetId(name)
if err != nil {
return
}
result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params)
return
}
// MustSet property on IDispatch with parameters.
func (d *Dispatch) MustSet(name string, params ...interface{}) (result *VARIANT) {
id, err := d.GetId(name)
if err != nil {
panic(err)
}
result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params)
if err != nil {
panic(err)
}
return
}
// GetId retrieves ID of name on IDispatch.
func (d *Dispatch) GetId(name string) (id int32, err error) {
var dispid []int32
dispid, err = d.Object.GetIDsOfName([]string{name})
if err != nil {
return
}
id = dispid[0]
return
}
// GetIds retrieves all IDs of names on IDispatch.
func (d *Dispatch) GetIds(names ...string) (dispid []int32, err error) {
dispid, err = d.Object.GetIDsOfName(names)
return
}
// Invoke IDispatch on DisplayID of dispatch type with parameters.
//
// There have been problems where if send cascading params..., it would error
// out because the parameters would be empty.
func (d *Dispatch) Invoke(id int32, dispatch int16, params []interface{}) (result *VARIANT, err error) {
if len(params) < 1 {
result, err = d.Object.Invoke(id, dispatch)
} else {
result, err = d.Object.Invoke(id, dispatch, params...)
}
return
}
// Release IDispatch object.
func (d *Dispatch) Release() {
d.Object.Release()
}
// Connect initializes COM and attempts to load IUnknown based on given names.
func Connect(names ...string) (connection *Connection) {
connection.Initialize()
connection.Load(names...)
return
}

159
gosuper/vendor/github.com/go-ole/go-ole/connect_test.go generated vendored
View File

@ -1,159 +0,0 @@
// +build !windows
package ole
import "strings"
func Example_quickbooks() {
var err error
connection := &Connection{nil}
err = connection.Initialize()
if err != nil {
return
}
defer connection.Uninitialize()
err = connection.Create("QBXMLRP2.RequestProcessor.1")
if err != nil {
if err.(*OleError).Code() == CO_E_CLASSSTRING {
return
}
}
defer connection.Release()
dispatch, err := connection.Dispatch()
if err != nil {
return
}
defer dispatch.Release()
}
func Example_quickbooksConnectHelperCallDispatch() {
var err error
connection := &Connection{nil}
err = connection.Initialize()
if err != nil {
return
}
defer connection.Uninitialize()
err = connection.Create("QBXMLRP2.RequestProcessor.1")
if err != nil {
if err.(*OleError).Code() == CO_E_CLASSSTRING {
return
}
return
}
defer connection.Release()
dispatch, err := connection.Dispatch()
if err != nil {
return
}
defer dispatch.Release()
var result *VARIANT
_, err = dispatch.Call("OpenConnection2", "", "Test Application 1", 1)
if err != nil {
return
}
result, err = dispatch.Call("BeginSession", "", 2)
if err != nil {
return
}
ticket := result.ToString()
_, err = dispatch.Call("EndSession", ticket)
if err != nil {
return
}
_, err = dispatch.Call("CloseConnection")
if err != nil {
return
}
}
func Example_quickbooksConnectHelperDispatchProperty() {
var err error
connection := &Connection{nil}
err = connection.Initialize()
if err != nil {
return
}
defer connection.Uninitialize()
err = connection.Create("QBXMLRP2.RequestProcessor.1")
if err != nil {
if err.(*OleError).Code() == CO_E_CLASSSTRING {
return
}
return
}
defer connection.Release()
dispatch, err := connection.Dispatch()
if err != nil {
return
}
defer dispatch.Release()
var result *VARIANT
_, err = dispatch.Call("OpenConnection2", "", "Test Application 1", 1)
if err != nil {
return
}
result, err = dispatch.Call("BeginSession", "", 2)
if err != nil {
return
}
ticket := result.ToString()
result, err = dispatch.Get("QBXMLVersionsForSession", ticket)
if err != nil {
return
}
conversion := result.ToArray()
totalElements, _ := conversion.TotalElements(0)
if totalElements != 13 {
return
}
versions := conversion.ToStringArray()
expectedVersionString := "1.0, 1.1, 2.0, 2.1, 3.0, 4.0, 4.1, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0"
versionString := strings.Join(versions, ", ")
if len(versions) != 13 {
return
}
if expectedVersionString != versionString {
return
}
conversion.Release()
_, err = dispatch.Call("EndSession", ticket)
if err != nil {
return
}
_, err = dispatch.Call("CloseConnection")
if err != nil {
return
}
}

181
gosuper/vendor/github.com/go-ole/go-ole/connect_windows_test.go generated vendored
View File

@ -1,181 +0,0 @@
// +build windows
package ole
import (
"fmt"
"strings"
"testing"
)
func Example_quickbooks() {
var err error
connection := &Connection{nil}
err = connection.Initialize()
if err != nil {
return
}
defer connection.Uninitialize()
err = connection.Create("QBXMLRP2.RequestProcessor.1")
if err != nil {
if err.(*OleError).Code() == CO_E_CLASSSTRING {
return
}
}
defer connection.Release()
dispatch, err := connection.Dispatch()
if err != nil {
return
}
defer dispatch.Release()
}
func TestConnectHelperCallDispatch_QuickBooks(t *testing.T) {
var err error
connection := &Connection{nil}
err = connection.Initialize()
if err != nil {
t.Log(err)
t.FailNow()
}
defer connection.Uninitialize()
err = connection.Create("QBXMLRP2.RequestProcessor.1")
if err != nil {
if err.(*OleError).Code() == CO_E_CLASSSTRING {
return
}
t.Log(err)
t.FailNow()
}
defer connection.Release()
dispatch, err := connection.Dispatch()
if err != nil {
t.Log(err)
t.FailNow()
}
defer dispatch.Release()
var result *VARIANT
_, err = dispatch.Call("OpenConnection2", "", "Test Application 1", 1)
if err != nil {
t.Log(err)
t.FailNow()
}
result, err = dispatch.Call("BeginSession", "", 2)
if err != nil {
t.Log(err)
t.FailNow()
}
ticket := result.ToString()
_, err = dispatch.Call("EndSession", ticket)
if err != nil {
t.Log(err)
t.Fail()
}
_, err = dispatch.Call("CloseConnection")
if err != nil {
t.Log(err)
t.Fail()
}
}
func TestConnectHelperDispatchProperty_QuickBooks(t *testing.T) {
var err error
connection := &Connection{nil}
err = connection.Initialize()
if err != nil {
t.Log(err)
t.FailNow()
}
defer connection.Uninitialize()
err = connection.Create("QBXMLRP2.RequestProcessor.1")
if err != nil {
if err.(*OleError).Code() == CO_E_CLASSSTRING {
return
}
t.Log(err)
t.FailNow()
}
defer connection.Release()
dispatch, err := connection.Dispatch()
if err != nil {
t.Log(err)
t.FailNow()
}
defer dispatch.Release()
var result *VARIANT
_, err = dispatch.Call("OpenConnection2", "", "Test Application 1", 1)
if err != nil {
t.Log(err)
t.FailNow()
}
result, err = dispatch.Call("BeginSession", "", 2)
if err != nil {
t.Log(err)
t.FailNow()
}
ticket := result.ToString()
result, err = dispatch.Get("QBXMLVersionsForSession", ticket)
if err != nil {
t.Log(err)
t.FailNow()
}
conversion := result.ToArray()
totalElements, _ := conversion.TotalElements(0)
if totalElements != 13 {
t.Log(fmt.Sprintf("%d total elements does not equal 13\n", totalElements))
t.Fail()
}
versions := conversion.ToStringArray()
expectedVersionString := "1.0, 1.1, 2.0, 2.1, 3.0, 4.0, 4.1, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0"
versionString := strings.Join(versions, ", ")
if len(versions) != 13 {
t.Log(fmt.Sprintf("%s\n", versionString))
t.Fail()
}
if expectedVersionString != versionString {
t.Log(fmt.Sprintf("Expected: %s\nActual: %s", expectedVersionString, versionString))
t.Fail()
}
conversion.Release()
_, err = dispatch.Call("EndSession", ticket)
if err != nil {
t.Log(err)
t.Fail()
}
_, err = dispatch.Call("CloseConnection")
if err != nil {
t.Log(err)
t.Fail()
}
}

153
gosuper/vendor/github.com/go-ole/go-ole/constants.go generated vendored
View File

@ -1,153 +0,0 @@
package ole
const (
CLSCTX_INPROC_SERVER = 1
CLSCTX_INPROC_HANDLER = 2
CLSCTX_LOCAL_SERVER = 4
CLSCTX_INPROC_SERVER16 = 8
CLSCTX_REMOTE_SERVER = 16
CLSCTX_ALL = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER
CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER
CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
)
const (
COINIT_APARTMENTTHREADED = 0x2
COINIT_MULTITHREADED = 0x0
COINIT_DISABLE_OLE1DDE = 0x4
COINIT_SPEED_OVER_MEMORY = 0x8
)
const (
DISPATCH_METHOD = 1
DISPATCH_PROPERTYGET = 2
DISPATCH_PROPERTYPUT = 4
DISPATCH_PROPERTYPUTREF = 8
)
const (
S_OK = 0x00000000
E_UNEXPECTED = 0x8000FFFF
E_NOTIMPL = 0x80004001
E_OUTOFMEMORY = 0x8007000E
E_INVALIDARG = 0x80070057
E_NOINTERFACE = 0x80004002
E_POINTER = 0x80004003
E_HANDLE = 0x80070006
E_ABORT = 0x80004004
E_FAIL = 0x80004005
E_ACCESSDENIED = 0x80070005
E_PENDING = 0x8000000A
CO_E_CLASSSTRING = 0x800401F3
)
const (
CC_FASTCALL = iota
CC_CDECL
CC_MSCPASCAL
CC_PASCAL = CC_MSCPASCAL
CC_MACPASCAL
CC_STDCALL
CC_FPFASTCALL
CC_SYSCALL
CC_MPWCDECL
CC_MPWPASCAL
CC_MAX = CC_MPWPASCAL
)
type VT uint16
const (
VT_EMPTY VT = 0x0
VT_NULL VT = 0x1
VT_I2 VT = 0x2
VT_I4 VT = 0x3
VT_R4 VT = 0x4
VT_R8 VT = 0x5
VT_CY VT = 0x6
VT_DATE VT = 0x7
VT_BSTR VT = 0x8
VT_DISPATCH VT = 0x9
VT_ERROR VT = 0xa
VT_BOOL VT = 0xb
VT_VARIANT VT = 0xc
VT_UNKNOWN VT = 0xd
VT_DECIMAL VT = 0xe
VT_I1 VT = 0x10
VT_UI1 VT = 0x11
VT_UI2 VT = 0x12
VT_UI4 VT = 0x13
VT_I8 VT = 0x14
VT_UI8 VT = 0x15
VT_INT VT = 0x16
VT_UINT VT = 0x17
VT_VOID VT = 0x18
VT_HRESULT VT = 0x19
VT_PTR VT = 0x1a
VT_SAFEARRAY VT = 0x1b
VT_CARRAY VT = 0x1c
VT_USERDEFINED VT = 0x1d
VT_LPSTR VT = 0x1e
VT_LPWSTR VT = 0x1f
VT_RECORD VT = 0x24
VT_INT_PTR VT = 0x25
VT_UINT_PTR VT = 0x26
VT_FILETIME VT = 0x40
VT_BLOB VT = 0x41
VT_STREAM VT = 0x42
VT_STORAGE VT = 0x43
VT_STREAMED_OBJECT VT = 0x44
VT_STORED_OBJECT VT = 0x45
VT_BLOB_OBJECT VT = 0x46
VT_CF VT = 0x47
VT_CLSID VT = 0x48
VT_BSTR_BLOB VT = 0xfff
VT_VECTOR VT = 0x1000
VT_ARRAY VT = 0x2000
VT_BYREF VT = 0x4000
VT_RESERVED VT = 0x8000
VT_ILLEGAL VT = 0xffff
VT_ILLEGALMASKED VT = 0xfff
VT_TYPEMASK VT = 0xfff
)
const (
DISPID_UNKNOWN = -1
DISPID_VALUE = 0
DISPID_PROPERTYPUT = -3
DISPID_NEWENUM = -4
DISPID_EVALUATE = -5
DISPID_CONSTRUCTOR = -6
DISPID_DESTRUCTOR = -7
DISPID_COLLECT = -8
)
const (
TKIND_ENUM = 1
TKIND_RECORD = 2
TKIND_MODULE = 3
TKIND_INTERFACE = 4
TKIND_DISPATCH = 5
TKIND_COCLASS = 6
TKIND_ALIAS = 7
TKIND_UNION = 8
TKIND_MAX = 9
)
// Safe Array Feature Flags
const (
FADF_AUTO = 0x0001
FADF_STATIC = 0x0002
FADF_EMBEDDED = 0x0004
FADF_FIXEDSIZE = 0x0010
FADF_RECORD = 0x0020
FADF_HAVEIID = 0x0040
FADF_HAVEVARTYPE = 0x0080
FADF_BSTR = 0x0100
FADF_UNKNOWN = 0x0200
FADF_DISPATCH = 0x0400
FADF_VARIANT = 0x0800
FADF_RESERVED = 0xF008
)

51
gosuper/vendor/github.com/go-ole/go-ole/error.go generated vendored
View File

@ -1,51 +0,0 @@
package ole
// OleError stores COM errors.
type OleError struct {
hr uintptr
description string
subError error
}
// NewError creates new error with HResult.
func NewError(hr uintptr) *OleError {
return &OleError{hr: hr}
}
// NewErrorWithDescription creates new COM error with HResult and description.
func NewErrorWithDescription(hr uintptr, description string) *OleError {
return &OleError{hr: hr, description: description}
}
// NewErrorWithSubError creates new COM error with parent error.
func NewErrorWithSubError(hr uintptr, description string, err error) *OleError {
return &OleError{hr: hr, description: description, subError: err}
}
// Code is the HResult.
func (v *OleError) Code() uintptr {
return uintptr(v.hr)
}
// String description, either manually set or format message with error code.
func (v *OleError) String() string {
if v.description != "" {
return errstr(int(v.hr)) + " (" + v.description + ")"
}
return errstr(int(v.hr))
}
// Error implements error interface.
func (v *OleError) Error() string {
return v.String()
}
// Description retrieves error summary, if there is one.
func (v *OleError) Description() string {
return v.description
}
// SubError returns parent error, if there is one.
func (v *OleError) SubError() error {
return v.subError
}

8
gosuper/vendor/github.com/go-ole/go-ole/error_func.go generated vendored
View File

@ -1,8 +0,0 @@
// +build !windows
package ole
// errstr converts error code to string.
func errstr(errno int) string {
return ""
}

24
gosuper/vendor/github.com/go-ole/go-ole/error_windows.go generated vendored
View File

@ -1,24 +0,0 @@
// +build windows
package ole
import (
"fmt"
"syscall"
"unicode/utf16"
)
// errstr converts error code to string.
func errstr(errno int) string {
// ask windows for the remaining errors
var flags uint32 = syscall.FORMAT_MESSAGE_FROM_SYSTEM | syscall.FORMAT_MESSAGE_ARGUMENT_ARRAY | syscall.FORMAT_MESSAGE_IGNORE_INSERTS
b := make([]uint16, 300)
n, err := syscall.FormatMessage(flags, 0, uint32(errno), 0, b, nil)
if err != nil {
return fmt.Sprintf("error %d (FormatMessage failed with: %v)", errno, err)
}
// trim terminating \r and \n
for ; n > 0 && (b[n-1] == '\n' || b[n-1] == '\r'); n-- {
}
return string(utf16.Decode(b[:n]))
}

31
gosuper/vendor/github.com/go-ole/go-ole/example/excel/excel.go generated vendored
View File

@ -1,31 +0,0 @@
// +build windows
package main
import (
"time"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
func main() {
ole.CoInitialize(0)
unknown, _ := oleutil.CreateObject("Excel.Application")
excel, _ := unknown.QueryInterface(ole.IID_IDispatch)
oleutil.PutProperty(excel, "Visible", true)
workbooks := oleutil.MustGetProperty(excel, "Workbooks").ToIDispatch()
workbook := oleutil.MustCallMethod(workbooks, "Add", nil).ToIDispatch()
worksheet := oleutil.MustGetProperty(workbook, "Worksheets", 1).ToIDispatch()
cell := oleutil.MustGetProperty(worksheet, "Cells", 1, 1).ToIDispatch()
oleutil.PutProperty(cell, "Value", 12345)
time.Sleep(2000000000)
oleutil.PutProperty(workbook, "Saved", true)
oleutil.CallMethod(workbook, "Close", false)
oleutil.CallMethod(excel, "Quit")
excel.Release()
ole.CoUninitialize()
}

96
gosuper/vendor/github.com/go-ole/go-ole/example/excel2/excel.go generated vendored
View File

@ -1,96 +0,0 @@
// +build windows
package main
import (
"fmt"
"log"
"os"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
func writeExample(excel, workbooks *ole.IDispatch, filepath string) {
// ref: https://msdn.microsoft.com/zh-tw/library/office/ff198017.aspx
// http://stackoverflow.com/questions/12159513/what-is-the-correct-xlfileformat-enumeration-for-excel-97-2003
const xlExcel8 = 56
workbook := oleutil.MustCallMethod(workbooks, "Add", nil).ToIDispatch()
defer workbook.Release()
worksheet := oleutil.MustGetProperty(workbook, "Worksheets", 1).ToIDispatch()
defer worksheet.Release()
cell := oleutil.MustGetProperty(worksheet, "Cells", 1, 1).ToIDispatch()
oleutil.PutProperty(cell, "Value", 12345)
cell.Release()
activeWorkBook := oleutil.MustGetProperty(excel, "ActiveWorkBook").ToIDispatch()
defer activeWorkBook.Release()
os.Remove(filepath)
// ref: https://msdn.microsoft.com/zh-tw/library/microsoft.office.tools.excel.workbook.saveas.aspx
oleutil.MustCallMethod(activeWorkBook, "SaveAs", filepath, xlExcel8, nil, nil).ToIDispatch()
//time.Sleep(2 * time.Second)
// let excel could close without asking
// oleutil.PutProperty(workbook, "Saved", true)
// oleutil.CallMethod(workbook, "Close", false)
}
func readExample(fileName string, excel, workbooks *ole.IDispatch) {
workbook, err := oleutil.CallMethod(workbooks, "Open", fileName)
if err != nil {
log.Fatalln(err)
}
defer workbook.ToIDispatch().Release()
sheets := oleutil.MustGetProperty(excel, "Sheets").ToIDispatch()
sheetCount := (int)(oleutil.MustGetProperty(sheets, "Count").Val)
fmt.Println("sheet count=", sheetCount)
sheets.Release()
worksheet := oleutil.MustGetProperty(workbook.ToIDispatch(), "Worksheets", 1).ToIDispatch()
defer worksheet.Release()
for row := 1; row <= 2; row++ {
for col := 1; col <= 5; col++ {
cell := oleutil.MustGetProperty(worksheet, "Cells", row, col).ToIDispatch()
val, err := oleutil.GetProperty(cell, "Value")
if err != nil {
break
}
fmt.Printf("(%d,%d)=%+v toString=%s\n", col, row, val.Value(), val.ToString())
cell.Release()
}
}
}
func showMethodsAndProperties(i *ole.IDispatch) {
n, err := i.GetTypeInfoCount()
if err != nil {
log.Fatalln(err)
}
tinfo, err := i.GetTypeInfo()
if err != nil {
log.Fatalln(err)
}
fmt.Println("n=", n, "tinfo=", tinfo)
}
func main() {
log.SetFlags(log.Flags() | log.Lshortfile)
ole.CoInitialize(0)
unknown, _ := oleutil.CreateObject("Excel.Application")
excel, _ := unknown.QueryInterface(ole.IID_IDispatch)
oleutil.PutProperty(excel, "Visible", true)
workbooks := oleutil.MustGetProperty(excel, "Workbooks").ToIDispatch()
cwd, _ := os.Getwd()
writeExample(excel, workbooks, cwd+"\\write.xls")
readExample(cwd+"\\excel97-2003.xls", excel, workbooks)
showMethodsAndProperties(workbooks)
workbooks.Release()
// oleutil.CallMethod(excel, "Quit")
excel.Release()
ole.CoUninitialize()
}

33
gosuper/vendor/github.com/go-ole/go-ole/example/ie/ie.go generated vendored
View File

@ -1,33 +0,0 @@
// +build windows
package main
import (
"time"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
func main() {
ole.CoInitialize(0)
unknown, _ := oleutil.CreateObject("InternetExplorer.Application")
ie, _ := unknown.QueryInterface(ole.IID_IDispatch)
oleutil.CallMethod(ie, "Navigate", "http://www.google.com")
oleutil.PutProperty(ie, "Visible", true)
for {
if oleutil.MustGetProperty(ie, "Busy").Val == 0 {
break
}
}
time.Sleep(1e9)
document := oleutil.MustGetProperty(ie, "document").ToIDispatch()
window := oleutil.MustGetProperty(document, "parentWindow").ToIDispatch()
// set 'golang' to text box.
oleutil.MustCallMethod(window, "eval", "document.getElementsByName('q')[0].value = 'golang'")
// click btnG.
btnG := oleutil.MustCallMethod(window, "eval", "document.getElementsByName('btnG')[0]").ToIDispatch()
oleutil.MustCallMethod(btnG, "click")
}

47
gosuper/vendor/github.com/go-ole/go-ole/example/itunes/itunes.go generated vendored
View File

@ -1,47 +0,0 @@
// +build windows
package main
import (
"log"
"os"
"strings"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
"github.com/gonuts/commander"
)
func iTunes() *ole.IDispatch {
ole.CoInitialize(0)
unknown, err := oleutil.CreateObject("iTunes.Application")
if err != nil {
log.Fatal(err)
}
itunes, err := unknown.QueryInterface(ole.IID_IDispatch)
if err != nil {
log.Fatal(err)
}
return itunes
}
func main() {
command := &commander.Command{
UsageLine: os.Args[0],
Short: "itunes cmd",
}
command.Subcommands = []*commander.Command{}
for _, name := range []string{"Play", "Stop", "Pause", "Quit"} {
command.Subcommands = append(command.Subcommands, &commander.Command{
Run: func(cmd *commander.Command, args []string) error {
_, err := oleutil.CallMethod(iTunes(), name)
return err
},
UsageLine: strings.ToLower(name),
})
}
err := command.Dispatch(os.Args[1:])
if err != nil {
log.Fatal(err)
}
}

162
gosuper/vendor/github.com/go-ole/go-ole/example/libreoffice/libreoffice.go generated vendored
View File

@ -1,162 +0,0 @@
// +build windows
/*
Demonstrates basic LibreOffce (OpenOffice) automation with OLE using GO-OLE.
Usage: cd [...]\go-ole\example\libreoffice
go run libreoffice.go
References:
http://www.openoffice.org/api/basic/man/tutorial/tutorial.pdf
http://api.libreoffice.org/examples/examples.html#OLE_examples
https://wiki.openoffice.org/wiki/Documentation/BASIC_Guide
Tested environment:
go 1.6.2 (windows/amd64)
LibreOffice 5.1.0.3 (32 bit)
Windows 10 (64 bit)
The MIT License (MIT)
Copyright (c) 2016 Sebastian Schleemilch <https://github.com/itschleemilch>.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the
following conditions:
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
OR OTHER DEALINGS IN THE SOFTWARE.
*/
package main
import (
"fmt"
"log"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
func checkError(err error, msg string) {
if err != nil {
log.Fatal(msg)
}
}
// LOGetCell returns an handle to a cell within a worksheet
// LibreOffice Basic: GetCell = oSheet.getCellByPosition (nColumn , nRow)
func LOGetCell(worksheet *ole.IDispatch, nColumn int, nRow int) (cell *ole.IDispatch) {
return oleutil.MustCallMethod(worksheet, "getCellByPosition", nColumn, nRow).ToIDispatch()
}
// LOGetCellRangeByName returns a named range (e.g. "A1:B4")
func LOGetCellRangeByName(worksheet *ole.IDispatch, rangeName string) (cells *ole.IDispatch) {
return oleutil.MustCallMethod(worksheet, "getCellRangeByName", rangeName).ToIDispatch()
}
// LOGetCellString returns the displayed value
func LOGetCellString(cell *ole.IDispatch) (value string) {
return oleutil.MustGetProperty(cell, "string").ToString()
}
// LOGetCellValue returns the cell's internal value (not formatted, dummy code, FIXME)
func LOGetCellValue(cell *ole.IDispatch) (value string) {
val := oleutil.MustGetProperty(cell, "value")
fmt.Printf("Cell: %+v\n", val)
return val.ToString()
}
// LOGetCellError returns the error value of a cell (dummy code, FIXME)
func LOGetCellError(cell *ole.IDispatch) (result *ole.VARIANT) {
return oleutil.MustGetProperty(cell, "error")
}
// LOSetCellString sets the text value of a cell
func LOSetCellString(cell *ole.IDispatch, text string) {
oleutil.MustPutProperty(cell, "string", text)
}
// LOSetCellValue sets the numeric value of a cell
func LOSetCellValue(cell *ole.IDispatch, value float64) {
oleutil.MustPutProperty(cell, "value", value)
}
// LOSetCellFormula sets the formula (in englisch language)
func LOSetCellFormula(cell *ole.IDispatch, formula string) {
oleutil.MustPutProperty(cell, "formula", formula)
}
// LOSetCellFormulaLocal sets the formula in the user's language (e.g. German =SUMME instead of =SUM)
func LOSetCellFormulaLocal(cell *ole.IDispatch, formula string) {
oleutil.MustPutProperty(cell, "FormulaLocal", formula)
}
// LONewSpreadsheet creates a new spreadsheet in a new window and returns a document handle.
func LONewSpreadsheet(desktop *ole.IDispatch) (document *ole.IDispatch) {
var args = []string{}
document = oleutil.MustCallMethod(desktop,
"loadComponentFromURL", "private:factory/scalc", // alternative: private:factory/swriter
"_blank", 0, args).ToIDispatch()
return
}
// LOOpenFile opens a file (text, spreadsheet, ...) in a new window and returns a document
// handle. Example: /home/testuser/spreadsheet.ods
func LOOpenFile(desktop *ole.IDispatch, fullpath string) (document *ole.IDispatch) {
var args = []string{}
document = oleutil.MustCallMethod(desktop,
"loadComponentFromURL", "file://"+fullpath,
"_blank", 0, args).ToIDispatch()
return
}
// LOSaveFile saves the current document.
// Only works if a file already exists,
// see https://wiki.openoffice.org/wiki/Saving_a_document
func LOSaveFile(document *ole.IDispatch) {
// use storeAsURL if neccessary with third URL parameter
oleutil.MustCallMethod(document, "store")
}
// LOGetWorksheet returns a worksheet (index starts at 0)
func LOGetWorksheet(document *ole.IDispatch, index int) (worksheet *ole.IDispatch) {
sheets := oleutil.MustGetProperty(document, "Sheets").ToIDispatch()
worksheet = oleutil.MustCallMethod(sheets, "getByIndex", index).ToIDispatch()
return
}
// This example creates a new spreadsheet, reads and modifies cell values and style.
func main() {
ole.CoInitialize(0)
unknown, errCreate := oleutil.CreateObject("com.sun.star.ServiceManager")
checkError(errCreate, "Couldn't create a OLE connection to LibreOffice")
ServiceManager, errSM := unknown.QueryInterface(ole.IID_IDispatch)
checkError(errSM, "Couldn't start a LibreOffice instance")
desktop := oleutil.MustCallMethod(ServiceManager,
"createInstance", "com.sun.star.frame.Desktop").ToIDispatch()
document := LONewSpreadsheet(desktop)
sheet0 := LOGetWorksheet(document, 0)
cell1_1 := LOGetCell(sheet0, 1, 1) // cell B2
cell1_2 := LOGetCell(sheet0, 1, 2) // cell B3
cell1_3 := LOGetCell(sheet0, 1, 3) // cell B4
cell1_4 := LOGetCell(sheet0, 1, 4) // cell B5
LOSetCellString(cell1_1, "Hello World")
LOSetCellValue(cell1_2, 33.45)
LOSetCellFormula(cell1_3, "=B3+5")
b4Value := LOGetCellString(cell1_3)
LOSetCellString(cell1_4, b4Value)
// set background color yellow:
oleutil.MustPutProperty(cell1_1, "cellbackcolor", 0xFFFF00)
fmt.Printf("Press [ENTER] to exit")
fmt.Scanf("%s")
ServiceManager.Release()
ole.CoUninitialize()
}

29
gosuper/vendor/github.com/go-ole/go-ole/example/mediaplayer/mediaplayer.go generated vendored
View File

@ -1,29 +0,0 @@
// +build windows
package main
import (
"fmt"
"log"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
func main() {
ole.CoInitialize(0)
unknown, err := oleutil.CreateObject("WMPlayer.OCX")
if err != nil {
log.Fatal(err)
}
wmp := unknown.MustQueryInterface(ole.IID_IDispatch)
collection := oleutil.MustGetProperty(wmp, "MediaCollection").ToIDispatch()
list := oleutil.MustCallMethod(collection, "getAll").ToIDispatch()
count := int(oleutil.MustGetProperty(list, "count").Val)
for i := 0; i < count; i++ {
item := oleutil.MustGetProperty(list, "item", i).ToIDispatch()
name := oleutil.MustGetProperty(item, "name").ToString()
sourceURL := oleutil.MustGetProperty(item, "sourceURL").ToString()
fmt.Println(name, sourceURL)
}
}

24
gosuper/vendor/github.com/go-ole/go-ole/example/msagent/msagent.go generated vendored
View File

@ -1,24 +0,0 @@
// +build windows
package main
import (
"time"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
func main() {
ole.CoInitialize(0)
unknown, _ := oleutil.CreateObject("Agent.Control.1")
agent, _ := unknown.QueryInterface(ole.IID_IDispatch)
oleutil.PutProperty(agent, "Connected", true)
characters := oleutil.MustGetProperty(agent, "Characters").ToIDispatch()
oleutil.CallMethod(characters, "Load", "Merlin", "c:\\windows\\msagent\\chars\\Merlin.acs")
character := oleutil.MustCallMethod(characters, "Character", "Merlin").ToIDispatch()
oleutil.CallMethod(character, "Show")
oleutil.CallMethod(character, "Speak", "こんにちわ世界")
time.Sleep(4000000000)
}

49
gosuper/vendor/github.com/go-ole/go-ole/example/msxml/rssreader.go generated vendored
View File

@ -1,49 +0,0 @@
// +build windows
package main
import (
"fmt"
"time"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
func main() {
ole.CoInitialize(0)
unknown, _ := oleutil.CreateObject("Microsoft.XMLHTTP")
xmlhttp, _ := unknown.QueryInterface(ole.IID_IDispatch)
_, err := oleutil.CallMethod(xmlhttp, "open", "GET", "http://rss.slashdot.org/Slashdot/slashdot", false)
if err != nil {
panic(err.Error())
}
_, err = oleutil.CallMethod(xmlhttp, "send", nil)
if err != nil {
panic(err.Error())
}
state := -1
for state != 4 {
state = int(oleutil.MustGetProperty(xmlhttp, "readyState").Val)
time.Sleep(10000000)
}
responseXml := oleutil.MustGetProperty(xmlhttp, "responseXml").ToIDispatch()
items := oleutil.MustCallMethod(responseXml, "selectNodes", "/rss/channel/item").ToIDispatch()
length := int(oleutil.MustGetProperty(items, "length").Val)
for n := 0; n < length; n++ {
item := oleutil.MustGetProperty(items, "item", n).ToIDispatch()
title := oleutil.MustCallMethod(item, "selectSingleNode", "title").ToIDispatch()
fmt.Println(oleutil.MustGetProperty(title, "text").ToString())
link := oleutil.MustCallMethod(item, "selectSingleNode", "link").ToIDispatch()
fmt.Println(" " + oleutil.MustGetProperty(link, "text").ToString())
title.Release()
link.Release()
item.Release()
}
items.Release()
xmlhttp.Release()
}

29
gosuper/vendor/github.com/go-ole/go-ole/example/outlook/outlook.go generated vendored
View File

@ -1,29 +0,0 @@
// +build windows
package main
import (
"fmt"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
func main() {
ole.CoInitialize(0)
unknown, _ := oleutil.CreateObject("Outlook.Application")
outlook, _ := unknown.QueryInterface(ole.IID_IDispatch)
ns := oleutil.MustCallMethod(outlook, "GetNamespace", "MAPI").ToIDispatch()
folder := oleutil.MustCallMethod(ns, "GetDefaultFolder", 10).ToIDispatch()
contacts := oleutil.MustCallMethod(folder, "Items").ToIDispatch()
count := oleutil.MustGetProperty(contacts, "Count").Value().(int32)
for i := 1; i <= int(count); i++ {
item, err := oleutil.GetProperty(contacts, "Item", i)
if err == nil && item.VT == ole.VT_DISPATCH {
if value, err := oleutil.GetProperty(item.ToIDispatch(), "FullName"); err == nil {
fmt.Println(value.Value())
}
}
}
oleutil.MustCallMethod(outlook, "Quit")
}

140
gosuper/vendor/github.com/go-ole/go-ole/example/winsock/winsock.go generated vendored
View File

@ -1,140 +0,0 @@
// +build windows
package main
import (
"log"
"syscall"
"unsafe"
ole "github.com/go-ole/go-ole"
"github.com/go-ole/go-ole/oleutil"
)
type EventReceiver struct {
lpVtbl *EventReceiverVtbl
ref int32
host *ole.IDispatch
}
type EventReceiverVtbl struct {
pQueryInterface uintptr
pAddRef uintptr
pRelease uintptr
pGetTypeInfoCount uintptr
pGetTypeInfo uintptr
pGetIDsOfNames uintptr
pInvoke uintptr
}
func QueryInterface(this *ole.IUnknown, iid *ole.GUID, punk **ole.IUnknown) uint32 {
s, _ := ole.StringFromCLSID(iid)
*punk = nil
if ole.IsEqualGUID(iid, ole.IID_IUnknown) ||
ole.IsEqualGUID(iid, ole.IID_IDispatch) {
AddRef(this)
*punk = this
return ole.S_OK
}
if s == "{248DD893-BB45-11CF-9ABC-0080C7E7B78D}" {
AddRef(this)
*punk = this
return ole.S_OK
}
return ole.E_NOINTERFACE
}
func AddRef(this *ole.IUnknown) int32 {
pthis := (*EventReceiver)(unsafe.Pointer(this))
pthis.ref++
return pthis.ref
}
func Release(this *ole.IUnknown) int32 {
pthis := (*EventReceiver)(unsafe.Pointer(this))
pthis.ref--
return pthis.ref
}
func GetIDsOfNames(this *ole.IUnknown, iid *ole.GUID, wnames []*uint16, namelen int, lcid int, pdisp []int32) uintptr {
for n := 0; n < namelen; n++ {
pdisp[n] = int32(n)
}
return uintptr(ole.S_OK)
}
func GetTypeInfoCount(pcount *int) uintptr {
if pcount != nil {
*pcount = 0
}
return uintptr(ole.S_OK)
}
func GetTypeInfo(ptypeif *uintptr) uintptr {
return uintptr(ole.E_NOTIMPL)
}
func Invoke(this *ole.IDispatch, dispid int, riid *ole.GUID, lcid int, flags int16, dispparams *ole.DISPPARAMS, result *ole.VARIANT, pexcepinfo *ole.EXCEPINFO, nerr *uint) uintptr {
switch dispid {
case 0:
log.Println("DataArrival")
winsock := (*EventReceiver)(unsafe.Pointer(this)).host
var data ole.VARIANT
ole.VariantInit(&data)
oleutil.CallMethod(winsock, "GetData", &data)
s := string(data.ToArray().ToByteArray())
println()
println(s)
println()
case 1:
log.Println("Connected")
winsock := (*EventReceiver)(unsafe.Pointer(this)).host
oleutil.CallMethod(winsock, "SendData", "GET / HTTP/1.0\r\n\r\n")
case 3:
log.Println("SendProgress")
case 4:
log.Println("SendComplete")
case 5:
log.Println("Close")
this.Release()
case 6:
log.Fatal("Error")
default:
log.Println(dispid)
}
return ole.E_NOTIMPL
}
func main() {
ole.CoInitialize(0)
unknown, err := oleutil.CreateObject("{248DD896-BB45-11CF-9ABC-0080C7E7B78D}")
if err != nil {
panic(err.Error())
}
winsock, _ := unknown.QueryInterface(ole.IID_IDispatch)
iid, _ := ole.CLSIDFromString("{248DD893-BB45-11CF-9ABC-0080C7E7B78D}")
dest := &EventReceiver{}
dest.lpVtbl = &EventReceiverVtbl{}
dest.lpVtbl.pQueryInterface = syscall.NewCallback(QueryInterface)
dest.lpVtbl.pAddRef = syscall.NewCallback(AddRef)
dest.lpVtbl.pRelease = syscall.NewCallback(Release)
dest.lpVtbl.pGetTypeInfoCount = syscall.NewCallback(GetTypeInfoCount)
dest.lpVtbl.pGetTypeInfo = syscall.NewCallback(GetTypeInfo)
dest.lpVtbl.pGetIDsOfNames = syscall.NewCallback(GetIDsOfNames)
dest.lpVtbl.pInvoke = syscall.NewCallback(Invoke)
dest.host = winsock
oleutil.ConnectObject(winsock, iid, (*ole.IUnknown)(unsafe.Pointer(dest)))
_, err = oleutil.CallMethod(winsock, "Connect", "127.0.0.1", 80)
if err != nil {
log.Fatal(err)
}
var m ole.Msg
for dest.ref != 0 {
ole.GetMessage(&m, 0, 0, 0)
ole.DispatchMessage(&m)
}
}

284
gosuper/vendor/github.com/go-ole/go-ole/guid.go generated vendored
View File

@ -1,284 +0,0 @@
package ole
var (
// IID_NULL is null Interface ID, used when no other Interface ID is known.
IID_NULL = NewGUID("{00000000-0000-0000-0000-000000000000}")
// IID_IUnknown is for IUnknown interfaces.
IID_IUnknown = NewGUID("{00000000-0000-0000-C000-000000000046}")
// IID_IDispatch is for IDispatch interfaces.
IID_IDispatch = NewGUID("{00020400-0000-0000-C000-000000000046}")
// IID_IEnumVariant is for IEnumVariant interfaces
IID_IEnumVariant = NewGUID("{00020404-0000-0000-C000-000000000046}")
// IID_IConnectionPointContainer is for IConnectionPointContainer interfaces.
IID_IConnectionPointContainer = NewGUID("{B196B284-BAB4-101A-B69C-00AA00341D07}")
// IID_IConnectionPoint is for IConnectionPoint interfaces.
IID_IConnectionPoint = NewGUID("{B196B286-BAB4-101A-B69C-00AA00341D07}")
// IID_IInspectable is for IInspectable interfaces.
IID_IInspectable = NewGUID("{AF86E2E0-B12D-4C6A-9C5A-D7AA65101E90}")
// IID_IProvideClassInfo is for IProvideClassInfo interfaces.
IID_IProvideClassInfo = NewGUID("{B196B283-BAB4-101A-B69C-00AA00341D07}")
)
// These are for testing and not part of any library.
var (
// IID_ICOMTestString is for ICOMTestString interfaces.
//
// {E0133EB4-C36F-469A-9D3D-C66B84BE19ED}
IID_ICOMTestString = NewGUID("{E0133EB4-C36F-469A-9D3D-C66B84BE19ED}")
// IID_ICOMTestInt8 is for ICOMTestInt8 interfaces.
//
// {BEB06610-EB84-4155-AF58-E2BFF53680B4}
IID_ICOMTestInt8 = NewGUID("{BEB06610-EB84-4155-AF58-E2BFF53680B4}")
// IID_ICOMTestInt16 is for ICOMTestInt16 interfaces.
//
// {DAA3F9FA-761E-4976-A860-8364CE55F6FC}
IID_ICOMTestInt16 = NewGUID("{DAA3F9FA-761E-4976-A860-8364CE55F6FC}")
// IID_ICOMTestInt32 is for ICOMTestInt32 interfaces.
//
// {E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}
IID_ICOMTestInt32 = NewGUID("{E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}")
// IID_ICOMTestInt64 is for ICOMTestInt64 interfaces.
//
// {8D437CBC-B3ED-485C-BC32-C336432A1623}
IID_ICOMTestInt64 = NewGUID("{8D437CBC-B3ED-485C-BC32-C336432A1623}")
// IID_ICOMTestFloat is for ICOMTestFloat interfaces.
//
// {BF1ED004-EA02-456A-AA55-2AC8AC6B054C}
IID_ICOMTestFloat = NewGUID("{BF1ED004-EA02-456A-AA55-2AC8AC6B054C}")
// IID_ICOMTestDouble is for ICOMTestDouble interfaces.
//
// {BF908A81-8687-4E93-999F-D86FAB284BA0}
IID_ICOMTestDouble = NewGUID("{BF908A81-8687-4E93-999F-D86FAB284BA0}")
// IID_ICOMTestBoolean is for ICOMTestBoolean interfaces.
//
// {D530E7A6-4EE8-40D1-8931-3D63B8605010}
IID_ICOMTestBoolean = NewGUID("{D530E7A6-4EE8-40D1-8931-3D63B8605010}")
// IID_ICOMEchoTestObject is for ICOMEchoTestObject interfaces.
//
// {6485B1EF-D780-4834-A4FE-1EBB51746CA3}
IID_ICOMEchoTestObject = NewGUID("{6485B1EF-D780-4834-A4FE-1EBB51746CA3}")
// IID_ICOMTestTypes is for ICOMTestTypes interfaces.
//
// {CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}
IID_ICOMTestTypes = NewGUID("{CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}")
// CLSID_COMEchoTestObject is for COMEchoTestObject class.
//
// {3C24506A-AE9E-4D50-9157-EF317281F1B0}
CLSID_COMEchoTestObject = NewGUID("{3C24506A-AE9E-4D50-9157-EF317281F1B0}")
// CLSID_COMTestScalarClass is for COMTestScalarClass class.
//
// {865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}
CLSID_COMTestScalarClass = NewGUID("{865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}")
)
const hextable = "0123456789ABCDEF"
const emptyGUID = "{00000000-0000-0000-0000-000000000000}"
// GUID is Windows API specific GUID type.
//
// This exists to match Windows GUID type for direct passing for COM.
// Format is in xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx.
type GUID struct {
Data1 uint32
Data2 uint16
Data3 uint16
Data4 [8]byte
}
// NewGUID converts the given string into a globally unique identifier that is
// compliant with the Windows API.
//
// The supplied string may be in any of these formats:
//
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
// {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
//
// The conversion of the supplied string is not case-sensitive.
func NewGUID(guid string) *GUID {
d := []byte(guid)
var d1, d2, d3, d4a, d4b []byte
switch len(d) {
case 38:
if d[0] != '{' || d[37] != '}' {
return nil
}
d = d[1:37]
fallthrough
case 36:
if d[8] != '-' || d[13] != '-' || d[18] != '-' || d[23] != '-' {
return nil
}
d1 = d[0:8]
d2 = d[9:13]
d3 = d[14:18]
d4a = d[19:23]
d4b = d[24:36]
case 32:
d1 = d[0:8]
d2 = d[8:12]
d3 = d[12:16]
d4a = d[16:20]
d4b = d[20:32]
default:
return nil
}
var g GUID
var ok1, ok2, ok3, ok4 bool
g.Data1, ok1 = decodeHexUint32(d1)
g.Data2, ok2 = decodeHexUint16(d2)
g.Data3, ok3 = decodeHexUint16(d3)
g.Data4, ok4 = decodeHexByte64(d4a, d4b)
if ok1 && ok2 && ok3 && ok4 {
return &g
}
return nil
}
func decodeHexUint32(src []byte) (value uint32, ok bool) {
var b1, b2, b3, b4 byte
var ok1, ok2, ok3, ok4 bool
b1, ok1 = decodeHexByte(src[0], src[1])
b2, ok2 = decodeHexByte(src[2], src[3])
b3, ok3 = decodeHexByte(src[4], src[5])
b4, ok4 = decodeHexByte(src[6], src[7])
value = (uint32(b1) << 24) | (uint32(b2) << 16) | (uint32(b3) << 8) | uint32(b4)
ok = ok1 && ok2 && ok3 && ok4
return
}
func decodeHexUint16(src []byte) (value uint16, ok bool) {
var b1, b2 byte
var ok1, ok2 bool
b1, ok1 = decodeHexByte(src[0], src[1])
b2, ok2 = decodeHexByte(src[2], src[3])
value = (uint16(b1) << 8) | uint16(b2)
ok = ok1 && ok2
return
}
func decodeHexByte64(s1 []byte, s2 []byte) (value [8]byte, ok bool) {
var ok1, ok2, ok3, ok4, ok5, ok6, ok7, ok8 bool
value[0], ok1 = decodeHexByte(s1[0], s1[1])
value[1], ok2 = decodeHexByte(s1[2], s1[3])
value[2], ok3 = decodeHexByte(s2[0], s2[1])
value[3], ok4 = decodeHexByte(s2[2], s2[3])
value[4], ok5 = decodeHexByte(s2[4], s2[5])
value[5], ok6 = decodeHexByte(s2[6], s2[7])
value[6], ok7 = decodeHexByte(s2[8], s2[9])
value[7], ok8 = decodeHexByte(s2[10], s2[11])
ok = ok1 && ok2 && ok3 && ok4 && ok5 && ok6 && ok7 && ok8
return
}
func decodeHexByte(c1, c2 byte) (value byte, ok bool) {
var n1, n2 byte
var ok1, ok2 bool
n1, ok1 = decodeHexChar(c1)
n2, ok2 = decodeHexChar(c2)
value = (n1 << 4) | n2
ok = ok1 && ok2
return
}
func decodeHexChar(c byte) (byte, bool) {
switch {
case '0' <= c && c <= '9':
return c - '0', true
case 'a' <= c && c <= 'f':
return c - 'a' + 10, true
case 'A' <= c && c <= 'F':
return c - 'A' + 10, true
}
return 0, false
}
// String converts the GUID to string form. It will adhere to this pattern:
//
// {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
//
// If the GUID is nil, the string representation of an empty GUID is returned:
//
// {00000000-0000-0000-0000-000000000000}
func (guid *GUID) String() string {
if guid == nil {
return emptyGUID
}
var c [38]byte
c[0] = '{'
putUint32Hex(c[1:9], guid.Data1)
c[9] = '-'
putUint16Hex(c[10:14], guid.Data2)
c[14] = '-'
putUint16Hex(c[15:19], guid.Data3)
c[19] = '-'
putByteHex(c[20:24], guid.Data4[0:2])
c[24] = '-'
putByteHex(c[25:37], guid.Data4[2:8])
c[37] = '}'
return string(c[:])
}
func putUint32Hex(b []byte, v uint32) {
b[0] = hextable[byte(v>>24)>>4]
b[1] = hextable[byte(v>>24)&0x0f]
b[2] = hextable[byte(v>>16)>>4]
b[3] = hextable[byte(v>>16)&0x0f]
b[4] = hextable[byte(v>>8)>>4]
b[5] = hextable[byte(v>>8)&0x0f]
b[6] = hextable[byte(v)>>4]
b[7] = hextable[byte(v)&0x0f]
}
func putUint16Hex(b []byte, v uint16) {
b[0] = hextable[byte(v>>8)>>4]
b[1] = hextable[byte(v>>8)&0x0f]
b[2] = hextable[byte(v)>>4]
b[3] = hextable[byte(v)&0x0f]
}
func putByteHex(dst, src []byte) {
for i := 0; i < len(src); i++ {
dst[i*2] = hextable[src[i]>>4]
dst[i*2+1] = hextable[src[i]&0x0f]
}
}
// IsEqualGUID compares two GUID.
//
// Not constant time comparison.
func IsEqualGUID(guid1 *GUID, guid2 *GUID) bool {
return guid1.Data1 == guid2.Data1 &&
guid1.Data2 == guid2.Data2 &&
guid1.Data3 == guid2.Data3 &&
guid1.Data4[0] == guid2.Data4[0] &&
guid1.Data4[1] == guid2.Data4[1] &&
guid1.Data4[2] == guid2.Data4[2] &&
guid1.Data4[3] == guid2.Data4[3] &&
guid1.Data4[4] == guid2.Data4[4] &&
guid1.Data4[5] == guid2.Data4[5] &&
guid1.Data4[6] == guid2.Data4[6] &&
guid1.Data4[7] == guid2.Data4[7]
}

80
gosuper/vendor/github.com/go-ole/go-ole/guid_test.go generated vendored
View File

@ -1,80 +0,0 @@
package ole
import (
"strings"
"testing"
)
var guidFixtures = []struct {
Name string
S string
G *GUID
ShouldMatch bool
}{
{"NULL", "{00000000-0000-0000-0000-000000000000}", &GUID{0x00000000, 0x0000, 0x0000, [8]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, true},
{"IUnknown", "{00000000-0000-0000-C000-000000000046}", &GUID{0x00000000, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}, true},
{"IDispatch", "{00020400-0000-0000-C000-000000000046}", &GUID{0x00020400, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}, true},
{"IEnumVariant", "{00020404-0000-0000-C000-000000000046}", &GUID{0x00020404, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}, true},
{"IConnectionPointContainer", "{B196B284-BAB4-101A-B69C-00AA00341D07}", &GUID{0xB196B284, 0xBAB4, 0x101A, [8]byte{0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07}}, true},
{"IConnectionPoint", "{B196B286-BAB4-101A-B69C-00AA00341D07}", &GUID{0xB196B286, 0xBAB4, 0x101A, [8]byte{0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07}}, true},
{"IInspectable", "{AF86E2E0-B12D-4C6A-9C5A-D7AA65101E90}", &GUID{0xaf86e2e0, 0xb12d, 0x4c6a, [8]byte{0x9c, 0x5a, 0xd7, 0xaa, 0x65, 0x10, 0x1e, 0x90}}, true},
{"IProvideClassInfo", "{B196B283-BAB4-101A-B69C-00AA00341D07}", &GUID{0xb196b283, 0xbab4, 0x101a, [8]byte{0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07}}, true},
{"ICOMTestInt64", "{8D437CBC-B3ED-485C-BC32-C336432A1623}", &GUID{0x8d437cbc, 0xb3ed, 0x485c, [8]byte{0xbc, 0x32, 0xc3, 0x36, 0x43, 0x2a, 0x16, 0x23}}, true},
{"Pattern1", "{10000000-1000-1000-1000-100000000000}", &GUID{0x10000000, 0x1000, 0x1000, [8]byte{0x10, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00}}, true},
{"Pattern2", "{01000000-0100-0100-0100-010000000000}", &GUID{0x01000000, 0x0100, 0x0100, [8]byte{0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}}, true},
{"Pattern3", "{00100000-0010-0010-0010-001000000000}", &GUID{0x00100000, 0x0010, 0x0010, [8]byte{0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00}}, true},
{"Pattern4", "{00010000-0001-0001-0001-000100000000}", &GUID{0x00010000, 0x0001, 0x0001, [8]byte{0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}}, true},
{"Pattern5", "{a000a000-a000-a000-a000-a000a000a000}", &GUID{0xa000a000, 0xa000, 0xa000, [8]byte{0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00}}, true},
{"Pattern6", "{0aaa0aaa-0aaa-0aaa-0aaa-0aaa0aaa0aaa}", &GUID{0x0aaa0aaa, 0x0aaa, 0x0aaa, [8]byte{0x0a, 0xaa, 0x0a, 0xaa, 0x0a, 0xaa, 0x0a, 0xaa}}, true},
{"Sequence1", "{12345678-1234-1234-1234-123456789abc}", &GUID{0x12345678, 0x1234, 0x1234, [8]byte{0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}}, true},
{"Sequence2", "12345678-1234-1234-1234-123456789abc", &GUID{0x12345678, 0x1234, 0x1234, [8]byte{0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}}, false},
{"Sequence3", "12345678123412341234123456789abc", &GUID{0x12345678, 0x1234, 0x1234, [8]byte{0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}}, false},
{"CaseUpper1", "{ABCDEFAB-ABCD-ABCD-ABCD-ABCDEFABCDEF}", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, true},
{"CaseUpper2", "ABCDEFAB-ABCD-ABCD-ABCD-ABCDEFABCDEF", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, false},
{"CaseUpper3", "ABCDEFABABCDABCDABCDABCDEFABCDEF", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, false},
{"CaseLower1", "{abcdefab-abcd-abcd-abcd-abcdefabcdef}", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, true},
{"CaseLower2", "abcdefab-abcd-abcd-abcd-abcdefabcdef", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, false},
{"CaseLower3", "abcdefababcdabcdabcdabcdefabcdef", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, false},
{"CaseMixed1", "{AbCdEfAb-AbCd-AbCd-AbCd-AbCdEfAbCdEf}", &GUID{0xabcdefab, 0xabcd, 0xabcd, [8]byte{0xab, 0xcd, 0xab, 0xcd, 0xef, 0xab, 0xcd, 0xef}}, true},
{"CaseMixed2", "{fEdCbAfE-fEdC-fEdC-fEdC-fEdCbAfEdCbA}", &GUID{0xfedcbafe, 0xfedc, 0xfedc, [8]byte{0xfe, 0xdc, 0xfe, 0xdc, 0xba, 0xfe, 0xdc, 0xba}}, true},
{"Empty", "", nil, false},
{"EmptyBrackets", "{}", nil, false},
{"GarbageDash1", "----", nil, false},
{"GarbageDash2", "------------------------------------", nil, false},
{"GarbageDash3", "{------------------------------------}", nil, false},
{"GarbagePadding1", " {abcdefab-abcd-abcd-abcd-abcdefabcdef}", nil, false},
{"GarbagePadding2", "{abcdefab-abcd-abcd-abcd-abcdefabcdef} ", nil, false},
{"GarbagePadding3", " abcdefab-abcd-abcd-abcd-abcdefabcdef", nil, false},
{"GarbagePadding4", "abcdefab-abcd-abcd-abcd-abcdefabcdef ", nil, false},
{"GarbagePadding5", " abcdefababcdabcdabcdabcdefabcdef", nil, false},
{"GarbagePadding6", "abcdefababcdabcdabcdabcdefabcdef ", nil, false},
{"Garbage1", "AFR*@)#$BNHRO*IABNFVaaa", nil, false},
{"Garbage2", "#@*%@#&^%382765*@^#*&^%R*@&#%R7632", nil, false},
{"Garbage3", "#@*%@#&^%382765*@^#*&^%R*@&#%R76377^2", nil, false},
{"Garbage4", "{ABCDEFA*-ABCD-ABCD-ABCD-ABCDEFABCDEF}", nil, false},
{"Garbage5", "{gggggggg-ABCD-ABCD-ABCD-ABCDEFABCDEF}", nil, false},
}
// TestGUID tests both NewGUID and GUID.String.
func TestGUID(t *testing.T) {
for i := 0; i < len(guidFixtures); i++ {
guid := NewGUID(guidFixtures[i].S)
f := guidFixtures[i]
if guid == nil {
if f.G != nil {
t.Errorf("GUID test \"%v\" (%v of %v) failed. Expected %v from NewGUID. Received <nil> instead.", f.Name, i, len(guidFixtures), f.G)
}
} else if f.G == nil {
t.Errorf("GUID test \"%v\" (%v of %v) failed. Expected <nil> from NewGUID. Received %v instead.", f.Name, i, len(guidFixtures), guid)
}
if guid == nil || f.G == nil {
continue
}
if !IsEqualGUID(guid, f.G) {
t.Errorf("GUID test \"%v\" (%v of %v) failed. Expected %v from NewGUID. Received %v instead.", f.Name, i, len(guidFixtures), f.G, guid)
}
if f.ShouldMatch && guid.String() != strings.ToUpper(f.S) {
t.Errorf("GUID test \"%v\" (%v of %v) failed. Expected \"%v\" from GUID.String. Received \"%v\" instead.", f.Name, i, len(guidFixtures), strings.ToUpper(f.S), guid)
}
}
}

20
gosuper/vendor/github.com/go-ole/go-ole/iconnectionpoint.go generated vendored
View File

@ -1,20 +0,0 @@
package ole
import "unsafe"
type IConnectionPoint struct {
IUnknown
}
type IConnectionPointVtbl struct {
IUnknownVtbl
GetConnectionInterface uintptr
GetConnectionPointContainer uintptr
Advise uintptr
Unadvise uintptr
EnumConnections uintptr
}
func (v *IConnectionPoint) VTable() *IConnectionPointVtbl {
return (*IConnectionPointVtbl)(unsafe.Pointer(v.RawVTable))
}

21
gosuper/vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go generated vendored
View File

@ -1,21 +0,0 @@
// +build !windows
package ole
import "unsafe"
func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 {
return int32(0)
}
func (v *IConnectionPoint) Advise(unknown *IUnknown) (uint32, error) {
return uint32(0), NewError(E_NOTIMPL)
}
func (v *IConnectionPoint) Unadvise(cookie uint32) error {
return NewError(E_NOTIMPL)
}
func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) (err error) {
return NewError(E_NOTIMPL)
}

43
gosuper/vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go generated vendored
View File

@ -1,43 +0,0 @@
// +build windows
package ole
import (
"syscall"
"unsafe"
)
func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 {
// XXX: This doesn't look like it does what it's supposed to
return release((*IUnknown)(unsafe.Pointer(v)))
}
func (v *IConnectionPoint) Advise(unknown *IUnknown) (cookie uint32, err error) {
hr, _, _ := syscall.Syscall(
v.VTable().Advise,
3,
uintptr(unsafe.Pointer(v)),
uintptr(unsafe.Pointer(unknown)),
uintptr(unsafe.Pointer(&cookie)))
if hr != 0 {
err = NewError(hr)
}
return
}
func (v *IConnectionPoint) Unadvise(cookie uint32) (err error) {
hr, _, _ := syscall.Syscall(
v.VTable().Unadvise,
2,
uintptr(unsafe.Pointer(v)),
uintptr(cookie),
0)
if hr != 0 {
err = NewError(hr)
}
return
}
func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) error {
return NewError(E_NOTIMPL)
}

17
gosuper/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go generated vendored
View File

@ -1,17 +0,0 @@
package ole
import "unsafe"
type IConnectionPointContainer struct {
IUnknown
}
type IConnectionPointContainerVtbl struct {
IUnknownVtbl
EnumConnectionPoints uintptr
FindConnectionPoint uintptr
}
func (v *IConnectionPointContainer) VTable() *IConnectionPointContainerVtbl {
return (*IConnectionPointContainerVtbl)(unsafe.Pointer(v.RawVTable))
}

11
gosuper/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go generated vendored
View File

@ -1,11 +0,0 @@
// +build !windows
package ole
func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error {
return NewError(E_NOTIMPL)
}
func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) error {
return NewError(E_NOTIMPL)
}

25
gosuper/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go generated vendored
View File

@ -1,25 +0,0 @@
// +build windows
package ole
import (
"syscall"
"unsafe"
)
func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error {
return NewError(E_NOTIMPL)
}
func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) (err error) {
hr, _, _ := syscall.Syscall(
v.VTable().FindConnectionPoint,
3,
uintptr(unsafe.Pointer(v)),
uintptr(unsafe.Pointer(iid)),
uintptr(unsafe.Pointer(point)))
if hr != 0 {
err = NewError(hr)
}
return
}

94
gosuper/vendor/github.com/go-ole/go-ole/idispatch.go generated vendored
View File

@ -1,94 +0,0 @@
package ole
import "unsafe"
type IDispatch struct {
IUnknown
}
type IDispatchVtbl struct {
IUnknownVtbl
GetTypeInfoCount uintptr
GetTypeInfo uintptr
GetIDsOfNames uintptr
Invoke uintptr
}
func (v *IDispatch) VTable() *IDispatchVtbl {
return (*IDispatchVtbl)(unsafe.Pointer(v.RawVTable))
}
func (v *IDispatch) GetIDsOfName(names []string) (dispid []int32, err error) {
dispid, err = getIDsOfName(v, names)
return
}
func (v *IDispatch) Invoke(dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) {
result, err = invoke(v, dispid, dispatch, params...)
return
}
func (v *IDispatch) GetTypeInfoCount() (c uint32, err error) {
c, err = getTypeInfoCount(v)
return
}
func (v *IDispatch) GetTypeInfo() (tinfo *ITypeInfo, err error) {
tinfo, err = getTypeInfo(v)
return
}
// GetSingleIDOfName is a helper that returns single display ID for IDispatch name.
//
// This replaces the common pattern of attempting to get a single name from the list of available
// IDs. It gives the first ID, if it is available.
func (v *IDispatch) GetSingleIDOfName(name string) (displayID int32, err error) {
var displayIDs []int32
displayIDs, err = v.GetIDsOfName([]string{name})
if err != nil {
return
}
displayID = displayIDs[0]
return
}
// InvokeWithOptionalArgs accepts arguments as an array, works like Invoke.
//
// Accepts name and will attempt to retrieve Display ID to pass to Invoke.
//
// Passing params as an array is a workaround that could be fixed in later versions of Go that
// prevent passing empty params. During testing it was discovered that this is an acceptable way of
// getting around not being able to pass params normally.
func (v *IDispatch) InvokeWithOptionalArgs(name string, dispatch int16, params []interface{}) (result *VARIANT, err error) {
displayID, err := v.GetSingleIDOfName(name)
if err != nil {
return
}
if len(params) < 1 {
result, err = v.Invoke(displayID, dispatch)
} else {
result, err = v.Invoke(displayID, dispatch, params...)
}
return
}
// CallMethod invokes named function with arguments on object.
func (v *IDispatch) CallMethod(name string, params ...interface{}) (*VARIANT, error) {
return v.InvokeWithOptionalArgs(name, DISPATCH_METHOD, params)
}
// GetProperty retrieves the property with the name with the ability to pass arguments.
//
// Most of the time you will not need to pass arguments as most objects do not allow for this
// feature. Or at least, should not allow for this feature. Some servers don't follow best practices
// and this is provided for those edge cases.
func (v *IDispatch) GetProperty(name string, params ...interface{}) (*VARIANT, error) {
return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYGET, params)
}
// PutProperty attempts to mutate a property in the object.
func (v *IDispatch) PutProperty(name string, params ...interface{}) (*VARIANT, error) {
return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYPUT, params)
}

19
gosuper/vendor/github.com/go-ole/go-ole/idispatch_func.go generated vendored
View File

@ -1,19 +0,0 @@
// +build !windows
package ole
func getIDsOfName(disp *IDispatch, names []string) ([]int32, error) {
return []int32{}, NewError(E_NOTIMPL)
}
func getTypeInfoCount(disp *IDispatch) (uint32, error) {
return uint32(0), NewError(E_NOTIMPL)
}
func getTypeInfo(disp *IDispatch) (*ITypeInfo, error) {
return nil, NewError(E_NOTIMPL)
}
func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (*VARIANT, error) {
return nil, NewError(E_NOTIMPL)
}

193
gosuper/vendor/github.com/go-ole/go-ole/idispatch_windows.go generated vendored
View File

@ -1,193 +0,0 @@
// +build windows
package ole
import (
"syscall"
"time"
"unsafe"
)
func getIDsOfName(disp *IDispatch, names []string) (dispid []int32, err error) {
wnames := make([]*uint16, len(names))
for i := 0; i < len(names); i++ {
wnames[i] = syscall.StringToUTF16Ptr(names[i])
}
dispid = make([]int32, len(names))
namelen := uint32(len(names))
hr, _, _ := syscall.Syscall6(
disp.VTable().GetIDsOfNames,
6,
uintptr(unsafe.Pointer(disp)),
uintptr(unsafe.Pointer(IID_NULL)),
uintptr(unsafe.Pointer(&wnames[0])),
uintptr(namelen),
uintptr(GetUserDefaultLCID()),
uintptr(unsafe.Pointer(&dispid[0])))
if hr != 0 {
err = NewError(hr)
}
return
}
func getTypeInfoCount(disp *IDispatch) (c uint32, err error) {
hr, _, _ := syscall.Syscall(
disp.VTable().GetTypeInfoCount,
2,
uintptr(unsafe.Pointer(disp)),
uintptr(unsafe.Pointer(&c)),
0)
if hr != 0 {
err = NewError(hr)
}
return
}
func getTypeInfo(disp *IDispatch) (tinfo *ITypeInfo, err error) {
hr, _, _ := syscall.Syscall(
disp.VTable().GetTypeInfo,
3,
uintptr(unsafe.Pointer(disp)),
uintptr(GetUserDefaultLCID()),
uintptr(unsafe.Pointer(&tinfo)))
if hr != 0 {
err = NewError(hr)
}
return
}
func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) {
var dispparams DISPPARAMS
if dispatch&DISPATCH_PROPERTYPUT != 0 {
dispnames := [1]int32{DISPID_PROPERTYPUT}
dispparams.rgdispidNamedArgs = uintptr(unsafe.Pointer(&dispnames[0]))
dispparams.cNamedArgs = 1
}
var vargs []VARIANT
if len(params) > 0 {
vargs = make([]VARIANT, len(params))
for i, v := range params {
//n := len(params)-i-1
n := len(params) - i - 1
VariantInit(&vargs[n])
switch vv := v.(type) {
case bool:
if vv {
vargs[n] = NewVariant(VT_BOOL, 0xffff)
} else {
vargs[n] = NewVariant(VT_BOOL, 0)
}
case *bool:
vargs[n] = NewVariant(VT_BOOL|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*bool)))))
case uint8:
vargs[n] = NewVariant(VT_I1, int64(v.(uint8)))
case *uint8:
vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8)))))
case int8:
vargs[n] = NewVariant(VT_I1, int64(v.(int8)))
case *int8:
vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8)))))
case int16:
vargs[n] = NewVariant(VT_I2, int64(v.(int16)))
case *int16:
vargs[n] = NewVariant(VT_I2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int16)))))
case uint16:
vargs[n] = NewVariant(VT_UI2, int64(v.(uint16)))
case *uint16:
vargs[n] = NewVariant(VT_UI2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint16)))))
case int32:
vargs[n] = NewVariant(VT_I4, int64(v.(int32)))
case *int32:
vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int32)))))
case uint32:
vargs[n] = NewVariant(VT_UI4, int64(v.(uint32)))
case *uint32:
vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint32)))))
case int64:
vargs[n] = NewVariant(VT_I8, int64(v.(int64)))
case *int64:
vargs[n] = NewVariant(VT_I8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int64)))))
case uint64:
vargs[n] = NewVariant(VT_UI8, int64(uintptr(v.(uint64))))
case *uint64:
vargs[n] = NewVariant(VT_UI8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint64)))))
case int:
vargs[n] = NewVariant(VT_I4, int64(v.(int)))
case *int:
vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int)))))
case uint:
vargs[n] = NewVariant(VT_UI4, int64(v.(uint)))
case *uint:
vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint)))))
case float32:
vargs[n] = NewVariant(VT_R4, *(*int64)(unsafe.Pointer(&vv)))
case *float32:
vargs[n] = NewVariant(VT_R4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float32)))))
case float64:
vargs[n] = NewVariant(VT_R8, *(*int64)(unsafe.Pointer(&vv)))
case *float64:
vargs[n] = NewVariant(VT_R8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float64)))))
case string:
vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(v.(string))))))
case *string:
vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*string)))))
case time.Time:
s := vv.Format("2006-01-02 15:04:05")
vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(s)))))
case *time.Time:
s := vv.Format("2006-01-02 15:04:05")
vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(&s))))
case *IDispatch:
vargs[n] = NewVariant(VT_DISPATCH, int64(uintptr(unsafe.Pointer(v.(*IDispatch)))))
case **IDispatch:
vargs[n] = NewVariant(VT_DISPATCH|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(**IDispatch)))))
case nil:
vargs[n] = NewVariant(VT_NULL, 0)
case *VARIANT:
vargs[n] = NewVariant(VT_VARIANT|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*VARIANT)))))
case []byte:
safeByteArray := safeArrayFromByteSlice(v.([]byte))
vargs[n] = NewVariant(VT_ARRAY|VT_UI1, int64(uintptr(unsafe.Pointer(safeByteArray))))
defer VariantClear(&vargs[n])
case []string:
safeByteArray := safeArrayFromStringSlice(v.([]string))
vargs[n] = NewVariant(VT_ARRAY|VT_BSTR, int64(uintptr(unsafe.Pointer(safeByteArray))))
defer VariantClear(&vargs[n])
default:
panic("unknown type")
}
}
dispparams.rgvarg = uintptr(unsafe.Pointer(&vargs[0]))
dispparams.cArgs = uint32(len(params))
}
result = new(VARIANT)
var excepInfo EXCEPINFO
VariantInit(result)
hr, _, _ := syscall.Syscall9(
disp.VTable().Invoke,
9,
uintptr(unsafe.Pointer(disp)),
uintptr(dispid),
uintptr(unsafe.Pointer(IID_NULL)),
uintptr(GetUserDefaultLCID()),
uintptr(dispatch),
uintptr(unsafe.Pointer(&dispparams)),
uintptr(unsafe.Pointer(result)),
uintptr(unsafe.Pointer(&excepInfo)),
0)
if hr != 0 {
err = NewErrorWithSubError(hr, BstrToString(excepInfo.bstrDescription), excepInfo)
}
for i, varg := range vargs {
n := len(params) - i - 1
if varg.VT == VT_BSTR && varg.Val != 0 {
SysFreeString(((*int16)(unsafe.Pointer(uintptr(varg.Val)))))
}
if varg.VT == (VT_BSTR|VT_BYREF) && varg.Val != 0 {
*(params[n].(*string)) = LpOleStrToString(*(**uint16)(unsafe.Pointer(uintptr(varg.Val))))
}
}
return
}

643
gosuper/vendor/github.com/go-ole/go-ole/idispatch_windows_test.go generated vendored
View File

@ -1,643 +0,0 @@
// +build windows
package ole
import "testing"
func wrapCOMExecute(t *testing.T, callback func(*testing.T)) {
defer func() {
if r := recover(); r != nil {
t.Error(r)
}
}()
err := CoInitialize(0)
if err != nil {
t.Fatal(err)
}
defer CoUninitialize()
callback(t)
}
func wrapDispatch(t *testing.T, ClassID, UnknownInterfaceID, DispatchInterfaceID *GUID, callback func(*testing.T, *IUnknown, *IDispatch)) {
var unknown *IUnknown
var dispatch *IDispatch
var err error
unknown, err = CreateInstance(ClassID, UnknownInterfaceID)
if err != nil {
t.Error(err)
return
}
defer unknown.Release()
dispatch, err = unknown.QueryInterface(DispatchInterfaceID)
if err != nil {
t.Error(err)
return
}
defer dispatch.Release()
callback(t, unknown, dispatch)
}
func wrapGoOLETestCOMServerEcho(t *testing.T, callback func(*testing.T, *IUnknown, *IDispatch)) {
wrapCOMExecute(t, func(t *testing.T) {
wrapDispatch(t, CLSID_COMEchoTestObject, IID_IUnknown, IID_ICOMEchoTestObject, callback)
})
}
func wrapGoOLETestCOMServerScalar(t *testing.T, callback func(*testing.T, *IUnknown, *IDispatch)) {
wrapCOMExecute(t, func(t *testing.T) {
wrapDispatch(t, CLSID_COMTestScalarClass, IID_IUnknown, IID_ICOMTestTypes, callback)
})
}
func TestIDispatch_goolecomserver_stringfield(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "StringField"
expected := "Test String"
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(string)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "string", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_int8field(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "Int8Field"
expected := int8(2)
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(int8)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int8", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_uint8field(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "UInt8Field"
expected := uint8(4)
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(uint8)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint8", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_int16field(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "Int16Field"
expected := int16(4)
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(int16)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int16", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_uint16field(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "UInt16Field"
expected := uint16(4)
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(uint16)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint16", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_int32field(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "Int32Field"
expected := int32(8)
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(int32)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int32", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_uint32field(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "UInt32Field"
expected := uint32(16)
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(uint32)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint32", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_int64field(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "Int64Field"
expected := int64(32)
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(int64)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int64", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_uint64field(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "UInt64Field"
expected := uint64(64)
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(uint64)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint64", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_booleanfield_true(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "BooleanField"
expected := true
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(bool)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "bool", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_booleanfield_false(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "BooleanField"
expected := false
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
return
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(bool)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "bool", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_float32field(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "Float32Field"
expected := float32(2.2)
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(float32)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float32", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_float64field(t *testing.T) {
wrapGoOLETestCOMServerScalar(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "Float64Field"
expected := float64(4.4)
_, err := idispatch.PutProperty(method, expected)
if err != nil {
t.Error(err)
}
variant, err := idispatch.GetProperty(method)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(float64)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float64", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echostring(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoString"
expected := "Test String"
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(string)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "string", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echoboolean(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoBoolean"
expected := true
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(bool)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "bool", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echoint8(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoInt8"
expected := int8(1)
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(int8)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int8", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echouint8(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoUInt8"
expected := uint8(1)
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(uint8)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint8", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echoint16(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoInt16"
expected := int16(1)
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(int16)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int16", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echouint16(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoUInt16"
expected := uint16(1)
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(uint16)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint16", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echoint32(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoInt32"
expected := int32(2)
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(int32)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int32", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echouint32(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoUInt32"
expected := uint32(4)
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(uint32)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint32", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echoint64(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoInt64"
expected := int64(1)
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(int64)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "int64", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echouint64(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoUInt64"
expected := uint64(1)
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(uint64)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "uint64", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echofloat32(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoFloat32"
expected := float32(2.2)
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(float32)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float32", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}
func TestIDispatch_goolecomserver_echofloat64(t *testing.T) {
wrapGoOLETestCOMServerEcho(t, func(t *testing.T, unknown *IUnknown, idispatch *IDispatch) {
method := "EchoFloat64"
expected := float64(2.2)
variant, err := idispatch.CallMethod(method, expected)
if err != nil {
t.Error(err)
return
}
defer variant.Clear()
actual, passed := variant.Value().(float64)
if !passed {
t.Errorf("%s() did not convert to %s, variant is %s with %v value", method, "float64", variant.VT, variant.Val)
return
}
if actual != expected {
t.Errorf("%s() expected %v did not match %v", method, expected, actual)
}
})
}

19
gosuper/vendor/github.com/go-ole/go-ole/ienumvariant.go generated vendored
View File

@ -1,19 +0,0 @@
package ole
import "unsafe"
type IEnumVARIANT struct {
IUnknown
}
type IEnumVARIANTVtbl struct {
IUnknownVtbl
Next uintptr
Skip uintptr
Reset uintptr
Clone uintptr
}
func (v *IEnumVARIANT) VTable() *IEnumVARIANTVtbl {
return (*IEnumVARIANTVtbl)(unsafe.Pointer(v.RawVTable))
}

19
gosuper/vendor/github.com/go-ole/go-ole/ienumvariant_func.go generated vendored
View File

@ -1,19 +0,0 @@
// +build !windows
package ole
func (enum *IEnumVARIANT) Clone() (*IEnumVARIANT, error) {
return nil, NewError(E_NOTIMPL)
}
func (enum *IEnumVARIANT) Reset() error {
return NewError(E_NOTIMPL)
}
func (enum *IEnumVARIANT) Skip(celt uint) error {
return NewError(E_NOTIMPL)
}
func (enum *IEnumVARIANT) Next(celt uint) (VARIANT, uint, error) {
return NewVariant(VT_NULL, int64(0)), 0, NewError(E_NOTIMPL)
}

101
gosuper/vendor/github.com/go-ole/go-ole/ienumvariant_test.go generated vendored
View File

@ -1,101 +0,0 @@
// +build windows
package ole
import "testing"
func TestIEnumVariant_wmi(t *testing.T) {
var err error
var classID *GUID
IID_ISWbemLocator := &GUID{0x76a6415b, 0xcb41, 0x11d1, [8]byte{0x8b, 0x02, 0x00, 0x60, 0x08, 0x06, 0xd9, 0xb6}}
err = CoInitialize(0)
if err != nil {
t.Errorf("Initialize error: %v", err)
}
defer CoUninitialize()
classID, err = ClassIDFrom("WbemScripting.SWbemLocator")
if err != nil {
t.Errorf("CreateObject WbemScripting.SWbemLocator returned with %v", err)
}
comserver, err := CreateInstance(classID, IID_IUnknown)
if err != nil {
t.Errorf("CreateInstance WbemScripting.SWbemLocator returned with %v", err)
}
if comserver == nil {
t.Error("CreateObject WbemScripting.SWbemLocator not an object")
}
defer comserver.Release()
dispatch, err := comserver.QueryInterface(IID_ISWbemLocator)
if err != nil {
t.Errorf("context.iunknown.QueryInterface returned with %v", err)
}
defer dispatch.Release()
wbemServices, err := dispatch.CallMethod("ConnectServer")
if err != nil {
t.Errorf("ConnectServer failed with %v", err)
}
defer wbemServices.Clear()
objectset, err := wbemServices.ToIDispatch().CallMethod("ExecQuery", "SELECT * FROM WIN32_Process")
if err != nil {
t.Errorf("ExecQuery failed with %v", err)
}
defer objectset.Clear()
enum_property, err := objectset.ToIDispatch().GetProperty("_NewEnum")
if err != nil {
t.Errorf("Get _NewEnum property failed with %v", err)
}
defer enum_property.Clear()
enum, err := enum_property.ToIUnknown().IEnumVARIANT(IID_IEnumVariant)
if err != nil {
t.Errorf("IEnumVARIANT() returned with %v", err)
}
if enum == nil {
t.Error("Enum is nil")
t.FailNow()
}
defer enum.Release()
for tmp, length, err := enum.Next(1); length > 0; tmp, length, err = enum.Next(1) {
if err != nil {
t.Errorf("Next() returned with %v", err)
}
tmp_dispatch := tmp.ToIDispatch()
defer tmp_dispatch.Release()
props, err := tmp_dispatch.GetProperty("Properties_")
if err != nil {
t.Errorf("Get Properties_ property failed with %v", err)
}
defer props.Clear()
props_enum_property, err := props.ToIDispatch().GetProperty("_NewEnum")
if err != nil {
t.Errorf("Get _NewEnum property failed with %v", err)
}
defer props_enum_property.Clear()
props_enum, err := props_enum_property.ToIUnknown().IEnumVARIANT(IID_IEnumVariant)
if err != nil {
t.Errorf("IEnumVARIANT failed with %v", err)
}
defer props_enum.Release()
class_variant, err := tmp_dispatch.GetProperty("Name")
if err != nil {
t.Errorf("Get Name property failed with %v", err)
}
defer class_variant.Clear()
class_name := class_variant.ToString()
t.Logf("Got %v", class_name)
}
}

63
gosuper/vendor/github.com/go-ole/go-ole/ienumvariant_windows.go generated vendored
View File

@ -1,63 +0,0 @@
// +build windows
package ole
import (
"syscall"
"unsafe"
)
func (enum *IEnumVARIANT) Clone() (cloned *IEnumVARIANT, err error) {
hr, _, _ := syscall.Syscall(
enum.VTable().Clone,
2,
uintptr(unsafe.Pointer(enum)),
uintptr(unsafe.Pointer(&cloned)),
0)
if hr != 0 {
err = NewError(hr)
}
return
}
func (enum *IEnumVARIANT) Reset() (err error) {
hr, _, _ := syscall.Syscall(
enum.VTable().Reset,
1,
uintptr(unsafe.Pointer(enum)),
0,
0)
if hr != 0 {
err = NewError(hr)
}
return
}
func (enum *IEnumVARIANT) Skip(celt uint) (err error) {
hr, _, _ := syscall.Syscall(
enum.VTable().Skip,
2,
uintptr(unsafe.Pointer(enum)),
uintptr(celt),
0)
if hr != 0 {
err = NewError(hr)
}
return
}
func (enum *IEnumVARIANT) Next(celt uint) (array VARIANT, length uint, err error) {
hr, _, _ := syscall.Syscall6(
enum.VTable().Next,
4,
uintptr(unsafe.Pointer(enum)),
uintptr(celt),
uintptr(unsafe.Pointer(&array)),
uintptr(unsafe.Pointer(&length)),
0,
0)
if hr != 0 {
err = NewError(hr)
}
return
}

18
gosuper/vendor/github.com/go-ole/go-ole/iinspectable.go generated vendored
View File

@ -1,18 +0,0 @@
package ole
import "unsafe"
type IInspectable struct {
IUnknown
}
type IInspectableVtbl struct {
IUnknownVtbl
GetIIds uintptr
GetRuntimeClassName uintptr
GetTrustLevel uintptr
}
func (v *IInspectable) VTable() *IInspectableVtbl {
return (*IInspectableVtbl)(unsafe.Pointer(v.RawVTable))
}

15
gosuper/vendor/github.com/go-ole/go-ole/iinspectable_func.go generated vendored
View File

@ -1,15 +0,0 @@
// +build !windows
package ole
func (v *IInspectable) GetIids() ([]*GUID, error) {
return []*GUID{}, NewError(E_NOTIMPL)
}
func (v *IInspectable) GetRuntimeClassName() (string, error) {
return "", NewError(E_NOTIMPL)
}
func (v *IInspectable) GetTrustLevel() (uint32, error) {
return uint32(0), NewError(E_NOTIMPL)
}

72
gosuper/vendor/github.com/go-ole/go-ole/iinspectable_windows.go generated vendored
View File

@ -1,72 +0,0 @@
// +build windows
package ole
import (
"bytes"
"encoding/binary"
"reflect"
"syscall"
"unsafe"
)
func (v *IInspectable) GetIids() (iids []*GUID, err error) {
var count uint32
var array uintptr
hr, _, _ := syscall.Syscall(
v.VTable().GetIIds,
3,
uintptr(unsafe.Pointer(v)),
uintptr(unsafe.Pointer(&count)),
uintptr(unsafe.Pointer(&array)))
if hr != 0 {
err = NewError(hr)
return
}
defer CoTaskMemFree(array)
iids = make([]*GUID, count)
byteCount := count * uint32(unsafe.Sizeof(GUID{}))
slicehdr := reflect.SliceHeader{Data: array, Len: int(byteCount), Cap: int(byteCount)}
byteSlice := *(*[]byte)(unsafe.Pointer(&slicehdr))
reader := bytes.NewReader(byteSlice)
for i := range iids {
guid := GUID{}
err = binary.Read(reader, binary.LittleEndian, &guid)
if err != nil {
return
}
iids[i] = &guid
}
return
}
func (v *IInspectable) GetRuntimeClassName() (s string, err error) {
var hstring HString
hr, _, _ := syscall.Syscall(
v.VTable().GetRuntimeClassName,
2,
uintptr(unsafe.Pointer(v)),
uintptr(unsafe.Pointer(&hstring)),
0)
if hr != 0 {
err = NewError(hr)
return
}
s = hstring.String()
DeleteHString(hstring)
return
}
func (v *IInspectable) GetTrustLevel() (level uint32, err error) {
hr, _, _ := syscall.Syscall(
v.VTable().GetTrustLevel,
2,
uintptr(unsafe.Pointer(v)),
uintptr(unsafe.Pointer(&level)),
0)
if hr != 0 {
err = NewError(hr)
}
return
}

21
gosuper/vendor/github.com/go-ole/go-ole/iprovideclassinfo.go generated vendored
View File

@ -1,21 +0,0 @@
package ole
import "unsafe"
type IProvideClassInfo struct {
IUnknown
}
type IProvideClassInfoVtbl struct {
IUnknownVtbl
GetClassInfo uintptr
}
func (v *IProvideClassInfo) VTable() *IProvideClassInfoVtbl {
return (*IProvideClassInfoVtbl)(unsafe.Pointer(v.RawVTable))
}
func (v *IProvideClassInfo) GetClassInfo() (cinfo *ITypeInfo, err error) {
cinfo, err = getClassInfo(v)
return
}

7
gosuper/vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go generated vendored
View File

@ -1,7 +0,0 @@
// +build !windows
package ole
func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
return nil, NewError(E_NOTIMPL)
}

21
gosuper/vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go generated vendored
View File

@ -1,21 +0,0 @@
// +build windows
package ole
import (
"syscall"
"unsafe"
)
func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
hr, _, _ := syscall.Syscall(
disp.VTable().GetClassInfo,
2,
uintptr(unsafe.Pointer(disp)),
uintptr(unsafe.Pointer(&tinfo)),
0)
if hr != 0 {
err = NewError(hr)
}
return
}

34
gosuper/vendor/github.com/go-ole/go-ole/itypeinfo.go generated vendored
View File

@ -1,34 +0,0 @@
package ole
import "unsafe"
type ITypeInfo struct {
IUnknown
}
type ITypeInfoVtbl struct {
IUnknownVtbl
GetTypeAttr uintptr
GetTypeComp uintptr
GetFuncDesc uintptr
GetVarDesc uintptr
GetNames uintptr
GetRefTypeOfImplType uintptr
GetImplTypeFlags uintptr
GetIDsOfNames uintptr
Invoke uintptr
GetDocumentation uintptr
GetDllEntry uintptr
GetRefTypeInfo uintptr
AddressOfMember uintptr
CreateInstance uintptr
GetMops uintptr
GetContainingTypeLib uintptr
ReleaseTypeAttr uintptr
ReleaseFuncDesc uintptr
ReleaseVarDesc uintptr
}
func (v *ITypeInfo) VTable() *ITypeInfoVtbl {
return (*ITypeInfoVtbl)(unsafe.Pointer(v.RawVTable))
}

7
gosuper/vendor/github.com/go-ole/go-ole/itypeinfo_func.go generated vendored
View File

@ -1,7 +0,0 @@
// +build !windows
package ole
func (v *ITypeInfo) GetTypeAttr() (*TYPEATTR, error) {
return nil, NewError(E_NOTIMPL)
}

21
gosuper/vendor/github.com/go-ole/go-ole/itypeinfo_windows.go generated vendored
View File

@ -1,21 +0,0 @@
// +build windows
package ole
import (
"syscall"
"unsafe"
)
func (v *ITypeInfo) GetTypeAttr() (tattr *TYPEATTR, err error) {
hr, _, _ := syscall.Syscall(
uintptr(v.VTable().GetTypeAttr),
2,
uintptr(unsafe.Pointer(v)),
uintptr(unsafe.Pointer(&tattr)),
0)
if hr != 0 {
err = NewError(hr)
}
return
}

57
gosuper/vendor/github.com/go-ole/go-ole/iunknown.go generated vendored
View File

@ -1,57 +0,0 @@
package ole
import "unsafe"
type IUnknown struct {
RawVTable *interface{}
}
type IUnknownVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
}
type UnknownLike interface {
QueryInterface(iid *GUID) (disp *IDispatch, err error)
AddRef() int32
Release() int32
}
func (v *IUnknown) VTable() *IUnknownVtbl {
return (*IUnknownVtbl)(unsafe.Pointer(v.RawVTable))
}
func (v *IUnknown) PutQueryInterface(interfaceID *GUID, obj interface{}) error {
return reflectQueryInterface(v, v.VTable().QueryInterface, interfaceID, obj)
}
func (v *IUnknown) IDispatch(interfaceID *GUID) (dispatch *IDispatch, err error) {
err = v.PutQueryInterface(interfaceID, &dispatch)
return
}
func (v *IUnknown) IEnumVARIANT(interfaceID *GUID) (enum *IEnumVARIANT, err error) {
err = v.PutQueryInterface(interfaceID, &enum)
return
}
func (v *IUnknown) QueryInterface(iid *GUID) (*IDispatch, error) {
return queryInterface(v, iid)
}
func (v *IUnknown) MustQueryInterface(iid *GUID) (disp *IDispatch) {
unk, err := queryInterface(v, iid)
if err != nil {
panic(err)
}
return unk
}
func (v *IUnknown) AddRef() int32 {
return addRef(v)
}
func (v *IUnknown) Release() int32 {
return release(v)
}

19
gosuper/vendor/github.com/go-ole/go-ole/iunknown_func.go generated vendored
View File

@ -1,19 +0,0 @@
// +build !windows
package ole
func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) {
return NewError(E_NOTIMPL)
}
func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) {
return nil, NewError(E_NOTIMPL)
}
func addRef(unk *IUnknown) int32 {
return 0
}
func release(unk *IUnknown) int32 {
return 0
}

58
gosuper/vendor/github.com/go-ole/go-ole/iunknown_windows.go generated vendored
View File

@ -1,58 +0,0 @@
// +build windows
package ole
import (
"reflect"
"syscall"
"unsafe"
)
func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) {
selfValue := reflect.ValueOf(self).Elem()
objValue := reflect.ValueOf(obj).Elem()
hr, _, _ := syscall.Syscall(
method,
3,
selfValue.UnsafeAddr(),
uintptr(unsafe.Pointer(interfaceID)),
objValue.Addr().Pointer())
if hr != 0 {
err = NewError(hr)
}
return
}
func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) {
hr, _, _ := syscall.Syscall(
unk.VTable().QueryInterface,
3,
uintptr(unsafe.Pointer(unk)),
uintptr(unsafe.Pointer(iid)),
uintptr(unsafe.Pointer(&disp)))
if hr != 0 {
err = NewError(hr)
}
return
}
func addRef(unk *IUnknown) int32 {
ret, _, _ := syscall.Syscall(
unk.VTable().AddRef,
1,
uintptr(unsafe.Pointer(unk)),
0,
0)
return int32(ret)
}
func release(unk *IUnknown) int32 {
ret, _, _ := syscall.Syscall(
unk.VTable().Release,
1,
uintptr(unsafe.Pointer(unk)),
0,
0)
return int32(ret)
}

32
gosuper/vendor/github.com/go-ole/go-ole/iunknown_windows_test.go generated vendored
View File

@ -1,32 +0,0 @@
// +build windows
package ole
import "testing"
func TestIUnknown(t *testing.T) {
defer func() {
if r := recover(); r != nil {
t.Error(r)
}
}()
var err error
err = CoInitialize(0)
if err != nil {
t.Fatal(err)
}
defer CoUninitialize()
var unknown *IUnknown
// oleutil.CreateObject()
unknown, err = CreateInstance(CLSID_COMEchoTestObject, IID_IUnknown)
if err != nil {
t.Fatal(err)
return
}
unknown.Release()
}

147
gosuper/vendor/github.com/go-ole/go-ole/ole.go generated vendored
View File

@ -1,147 +0,0 @@
package ole
import (
"fmt"
"strings"
)
// DISPPARAMS are the arguments that passed to methods or property.
type DISPPARAMS struct {
rgvarg uintptr
rgdispidNamedArgs uintptr
cArgs uint32
cNamedArgs uint32
}
// EXCEPINFO defines exception info.
type EXCEPINFO struct {
wCode uint16
wReserved uint16
bstrSource *uint16
bstrDescription *uint16
bstrHelpFile *uint16
dwHelpContext uint32
pvReserved uintptr
pfnDeferredFillIn uintptr
scode uint32
}
// String convert EXCEPINFO to string.
func (e EXCEPINFO) String() string {
var src, desc, hlp string
if e.bstrSource == nil {
src = "<nil>"
} else {
src = BstrToString(e.bstrSource)
}
if e.bstrDescription == nil {
desc = "<nil>"
} else {
desc = BstrToString(e.bstrDescription)
}
if e.bstrHelpFile == nil {
hlp = "<nil>"
} else {
hlp = BstrToString(e.bstrHelpFile)
}
return fmt.Sprintf(
"wCode: %#x, bstrSource: %v, bstrDescription: %v, bstrHelpFile: %v, dwHelpContext: %#x, scode: %#x",
e.wCode, src, desc, hlp, e.dwHelpContext, e.scode,
)
}
// Error implements error interface and returns error string.
func (e EXCEPINFO) Error() string {
if e.bstrDescription != nil {
return strings.TrimSpace(BstrToString(e.bstrDescription))
}
src := "Unknown"
if e.bstrSource != nil {
src = BstrToString(e.bstrSource)
}
code := e.scode
if e.wCode != 0 {
code = uint32(e.wCode)
}
return fmt.Sprintf("%v: %#x", src, code)
}
// PARAMDATA defines parameter data type.
type PARAMDATA struct {
Name *int16
Vt uint16
}
// METHODDATA defines method info.
type METHODDATA struct {
Name *uint16
Data *PARAMDATA
Dispid int32
Meth uint32
CC int32
CArgs uint32
Flags uint16
VtReturn uint32
}
// INTERFACEDATA defines interface info.
type INTERFACEDATA struct {
MethodData *METHODDATA
CMembers uint32
}
// Point is 2D vector type.
type Point struct {
X int32
Y int32
}
// Msg is message between processes.
type Msg struct {
Hwnd uint32
Message uint32
Wparam int32
Lparam int32
Time uint32
Pt Point
}
// TYPEDESC defines data type.
type TYPEDESC struct {
Hreftype uint32
VT uint16
}
// IDLDESC defines IDL info.
type IDLDESC struct {
DwReserved uint32
WIDLFlags uint16
}
// TYPEATTR defines type info.
type TYPEATTR struct {
Guid GUID
Lcid uint32
dwReserved uint32
MemidConstructor int32
MemidDestructor int32
LpstrSchema *uint16
CbSizeInstance uint32
Typekind int32
CFuncs uint16
CVars uint16
CImplTypes uint16
CbSizeVft uint16
CbAlignment uint16
WTypeFlags uint16
WMajorVerNum uint16
WMinorVerNum uint16
TdescAlias TYPEDESC
IdldescType IDLDESC
}

100
gosuper/vendor/github.com/go-ole/go-ole/oleutil/connection.go generated vendored
View File

@ -1,100 +0,0 @@
// +build windows
package oleutil
import (
"reflect"
"unsafe"
ole "github.com/go-ole/go-ole"
)
type stdDispatch struct {
lpVtbl *stdDispatchVtbl
ref int32
iid *ole.GUID
iface interface{}
funcMap map[string]int32
}
type stdDispatchVtbl struct {
pQueryInterface uintptr
pAddRef uintptr
pRelease uintptr
pGetTypeInfoCount uintptr
pGetTypeInfo uintptr
pGetIDsOfNames uintptr
pInvoke uintptr
}
func dispQueryInterface(this *ole.IUnknown, iid *ole.GUID, punk **ole.IUnknown) uint32 {
pthis := (*stdDispatch)(unsafe.Pointer(this))
*punk = nil
if ole.IsEqualGUID(iid, ole.IID_IUnknown) ||
ole.IsEqualGUID(iid, ole.IID_IDispatch) {
dispAddRef(this)
*punk = this
return ole.S_OK
}
if ole.IsEqualGUID(iid, pthis.iid) {
dispAddRef(this)
*punk = this
return ole.S_OK
}
return ole.E_NOINTERFACE
}
func dispAddRef(this *ole.IUnknown) int32 {
pthis := (*stdDispatch)(unsafe.Pointer(this))
pthis.ref++
return pthis.ref
}
func dispRelease(this *ole.IUnknown) int32 {
pthis := (*stdDispatch)(unsafe.Pointer(this))
pthis.ref--
return pthis.ref
}
func dispGetIDsOfNames(this *ole.IUnknown, iid *ole.GUID, wnames []*uint16, namelen int, lcid int, pdisp []int32) uintptr {
pthis := (*stdDispatch)(unsafe.Pointer(this))
names := make([]string, len(wnames))
for i := 0; i < len(names); i++ {
names[i] = ole.LpOleStrToString(wnames[i])
}
for n := 0; n < namelen; n++ {
if id, ok := pthis.funcMap[names[n]]; ok {
pdisp[n] = id
}
}
return ole.S_OK
}
func dispGetTypeInfoCount(pcount *int) uintptr {
if pcount != nil {
*pcount = 0
}
return ole.S_OK
}
func dispGetTypeInfo(ptypeif *uintptr) uintptr {
return ole.E_NOTIMPL
}
func dispInvoke(this *ole.IDispatch, dispid int32, riid *ole.GUID, lcid int, flags int16, dispparams *ole.DISPPARAMS, result *ole.VARIANT, pexcepinfo *ole.EXCEPINFO, nerr *uint) uintptr {
pthis := (*stdDispatch)(unsafe.Pointer(this))
found := ""
for name, id := range pthis.funcMap {
if id == dispid {
found = name
}
}
if found != "" {
rv := reflect.ValueOf(pthis.iface).Elem()
rm := rv.MethodByName(found)
rr := rm.Call([]reflect.Value{})
println(len(rr))
return ole.S_OK
}
return ole.E_NOTIMPL
}

10
gosuper/vendor/github.com/go-ole/go-ole/oleutil/connection_func.go generated vendored
View File

@ -1,10 +0,0 @@
// +build !windows
package oleutil
import ole "github.com/go-ole/go-ole"
// ConnectObject creates a connection point between two services for communication.
func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (uint32, error) {
return 0, ole.NewError(ole.E_NOTIMPL)
}

58
gosuper/vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go generated vendored
View File

@ -1,58 +0,0 @@
// +build windows
package oleutil
import (
"reflect"
"syscall"
"unsafe"
ole "github.com/go-ole/go-ole"
)
// ConnectObject creates a connection point between two services for communication.
func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (cookie uint32, err error) {
unknown, err := disp.QueryInterface(ole.IID_IConnectionPointContainer)
if err != nil {
return
}
container := (*ole.IConnectionPointContainer)(unsafe.Pointer(unknown))
var point *ole.IConnectionPoint
err = container.FindConnectionPoint(iid, &point)
if err != nil {
return
}
if edisp, ok := idisp.(*ole.IUnknown); ok {
cookie, err = point.Advise(edisp)
container.Release()
if err != nil {
return
}
}
rv := reflect.ValueOf(disp).Elem()
if rv.Type().Kind() == reflect.Struct {
dest := &stdDispatch{}
dest.lpVtbl = &stdDispatchVtbl{}
dest.lpVtbl.pQueryInterface = syscall.NewCallback(dispQueryInterface)
dest.lpVtbl.pAddRef = syscall.NewCallback(dispAddRef)
dest.lpVtbl.pRelease = syscall.NewCallback(dispRelease)
dest.lpVtbl.pGetTypeInfoCount = syscall.NewCallback(dispGetTypeInfoCount)
dest.lpVtbl.pGetTypeInfo = syscall.NewCallback(dispGetTypeInfo)
dest.lpVtbl.pGetIDsOfNames = syscall.NewCallback(dispGetIDsOfNames)
dest.lpVtbl.pInvoke = syscall.NewCallback(dispInvoke)
dest.iface = disp
dest.iid = iid
cookie, err = point.Advise((*ole.IUnknown)(unsafe.Pointer(dest)))
container.Release()
if err != nil {
point.Release()
return
}
return
}
container.Release()
return 0, ole.NewError(ole.E_INVALIDARG)
}

6
gosuper/vendor/github.com/go-ole/go-ole/oleutil/go-get.go generated vendored
View File

@ -1,6 +0,0 @@
// This file is here so go get succeeds as without it errors with:
// no buildable Go source files in ...
//
// +build !windows
package oleutil

113
gosuper/vendor/github.com/go-ole/go-ole/oleutil/oleutil.go generated vendored
View File

@ -1,113 +0,0 @@
package oleutil
import ole "github.com/go-ole/go-ole"
// ClassIDFrom retrieves class ID whether given is program ID or application string.
func ClassIDFrom(programID string) (classID *ole.GUID, err error) {
return ole.ClassIDFrom(programID)
}
// CreateObject creates object from programID based on interface type.
//
// Only supports IUnknown.
//
// Program ID can be either program ID or application string.
func CreateObject(programID string) (unknown *ole.IUnknown, err error) {
classID, err := ole.ClassIDFrom(programID)
if err != nil {
return
}
unknown, err = ole.CreateInstance(classID, ole.IID_IUnknown)
if err != nil {
return
}
return
}
// GetActiveObject retrieves active object for program ID and interface ID based
// on interface type.
//
// Only supports IUnknown.
//
// Program ID can be either program ID or application string.
func GetActiveObject(programID string) (unknown *ole.IUnknown, err error) {
classID, err := ole.ClassIDFrom(programID)
if err != nil {
return
}
unknown, err = ole.GetActiveObject(classID, ole.IID_IUnknown)
if err != nil {
return
}
return
}
// CallMethod calls method on IDispatch with parameters.
func CallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_METHOD, params)
}
// MustCallMethod calls method on IDispatch with parameters or panics.
func MustCallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
r, err := CallMethod(disp, name, params...)
if err != nil {
panic(err.Error())
}
return r
}
// GetProperty retrieves property from IDispatch.
func GetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYGET, params)
}
// MustGetProperty retrieves property from IDispatch or panics.
func MustGetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
r, err := GetProperty(disp, name, params...)
if err != nil {
panic(err.Error())
}
return r
}
// PutProperty mutates property.
func PutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUT, params)
}
// MustPutProperty mutates property or panics.
func MustPutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
r, err := PutProperty(disp, name, params...)
if err != nil {
panic(err.Error())
}
return r
}
func ForEach(disp *ole.IDispatch, f func(v *ole.VARIANT) error) error {
newEnum, err := disp.GetProperty("_NewEnum")
if err != nil {
return err
}
defer newEnum.Clear()
enum, err := newEnum.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
if err != nil {
return err
}
defer enum.Release()
for item, length, err := enum.Next(1); length > 0; item, length, err = enum.Next(1) {
if err != nil {
return err
}
if ferr := f(&item); ferr != nil {
return ferr
}
}
return nil
}

27
gosuper/vendor/github.com/go-ole/go-ole/safearray.go generated vendored
View File

@ -1,27 +0,0 @@
// Package is meant to retrieve and process safe array data returned from COM.
package ole
// SafeArrayBound defines the SafeArray boundaries.
type SafeArrayBound struct {
Elements uint32
LowerBound int32
}
// SafeArray is how COM handles arrays.
type SafeArray struct {
Dimensions uint16
FeaturesFlag uint16
ElementsSize uint32
LocksAmount uint32
Data uint32
Bounds [16]byte
}
// SAFEARRAY is obsolete, exists for backwards compatibility.
// Use SafeArray
type SAFEARRAY SafeArray
// SAFEARRAYBOUND is obsolete, exists for backwards compatibility.
// Use SafeArrayBound
type SAFEARRAYBOUND SafeArrayBound

211
gosuper/vendor/github.com/go-ole/go-ole/safearray_func.go generated vendored
View File

@ -1,211 +0,0 @@
// +build !windows
package ole
import (
"unsafe"
)
// safeArrayAccessData returns raw array pointer.
//
// AKA: SafeArrayAccessData in Windows API.
func safeArrayAccessData(safearray *SafeArray) (uintptr, error) {
return uintptr(0), NewError(E_NOTIMPL)
}
// safeArrayUnaccessData releases raw array.
//
// AKA: SafeArrayUnaccessData in Windows API.
func safeArrayUnaccessData(safearray *SafeArray) error {
return NewError(E_NOTIMPL)
}
// safeArrayAllocData allocates SafeArray.
//
// AKA: SafeArrayAllocData in Windows API.
func safeArrayAllocData(safearray *SafeArray) error {
return NewError(E_NOTIMPL)
}
// safeArrayAllocDescriptor allocates SafeArray.
//
// AKA: SafeArrayAllocDescriptor in Windows API.
func safeArrayAllocDescriptor(dimensions uint32) (*SafeArray, error) {
return nil, NewError(E_NOTIMPL)
}
// safeArrayAllocDescriptorEx allocates SafeArray.
//
// AKA: SafeArrayAllocDescriptorEx in Windows API.
func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (*SafeArray, error) {
return nil, NewError(E_NOTIMPL)
}
// safeArrayCopy returns copy of SafeArray.
//
// AKA: SafeArrayCopy in Windows API.
func safeArrayCopy(original *SafeArray) (*SafeArray, error) {
return nil, NewError(E_NOTIMPL)
}
// safeArrayCopyData duplicates SafeArray into another SafeArray object.
//
// AKA: SafeArrayCopyData in Windows API.
func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) error {
return NewError(E_NOTIMPL)
}
// safeArrayCreate creates SafeArray.
//
// AKA: SafeArrayCreate in Windows API.
func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (*SafeArray, error) {
return nil, NewError(E_NOTIMPL)
}
// safeArrayCreateEx creates SafeArray.
//
// AKA: SafeArrayCreateEx in Windows API.
func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (*SafeArray, error) {
return nil, NewError(E_NOTIMPL)
}
// safeArrayCreateVector creates SafeArray.
//
// AKA: SafeArrayCreateVector in Windows API.
func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (*SafeArray, error) {
return nil, NewError(E_NOTIMPL)
}
// safeArrayCreateVectorEx creates SafeArray.
//
// AKA: SafeArrayCreateVectorEx in Windows API.
func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (*SafeArray, error) {
return nil, NewError(E_NOTIMPL)
}
// safeArrayDestroy destroys SafeArray object.
//
// AKA: SafeArrayDestroy in Windows API.
func safeArrayDestroy(safearray *SafeArray) error {
return NewError(E_NOTIMPL)
}
// safeArrayDestroyData destroys SafeArray object.
//
// AKA: SafeArrayDestroyData in Windows API.
func safeArrayDestroyData(safearray *SafeArray) error {
return NewError(E_NOTIMPL)
}
// safeArrayDestroyDescriptor destroys SafeArray object.
//
// AKA: SafeArrayDestroyDescriptor in Windows API.
func safeArrayDestroyDescriptor(safearray *SafeArray) error {
return NewError(E_NOTIMPL)
}
// safeArrayGetDim is the amount of dimensions in the SafeArray.
//
// SafeArrays may have multiple dimensions. Meaning, it could be
// multidimensional array.
//
// AKA: SafeArrayGetDim in Windows API.
func safeArrayGetDim(safearray *SafeArray) (*uint32, error) {
u := uint32(0)
return &u, NewError(E_NOTIMPL)
}
// safeArrayGetElementSize is the element size in bytes.
//
// AKA: SafeArrayGetElemsize in Windows API.
func safeArrayGetElementSize(safearray *SafeArray) (*uint32, error) {
u := uint32(0)
return &u, NewError(E_NOTIMPL)
}
// safeArrayGetElement retrieves element at given index.
func safeArrayGetElement(safearray *SafeArray, index int64, pv unsafe.Pointer) error {
return NewError(E_NOTIMPL)
}
// safeArrayGetElement retrieves element at given index and converts to string.
func safeArrayGetElementString(safearray *SafeArray, index int64) (string, error) {
return "", NewError(E_NOTIMPL)
}
// safeArrayGetIID is the InterfaceID of the elements in the SafeArray.
//
// AKA: SafeArrayGetIID in Windows API.
func safeArrayGetIID(safearray *SafeArray) (*GUID, error) {
return nil, NewError(E_NOTIMPL)
}
// safeArrayGetLBound returns lower bounds of SafeArray.
//
// SafeArrays may have multiple dimensions. Meaning, it could be
// multidimensional array.
//
// AKA: SafeArrayGetLBound in Windows API.
func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (int64, error) {
return int64(0), NewError(E_NOTIMPL)
}
// safeArrayGetUBound returns upper bounds of SafeArray.
//
// SafeArrays may have multiple dimensions. Meaning, it could be
// multidimensional array.
//
// AKA: SafeArrayGetUBound in Windows API.
func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (int64, error) {
return int64(0), NewError(E_NOTIMPL)
}
// safeArrayGetVartype returns data type of SafeArray.
//
// AKA: SafeArrayGetVartype in Windows API.
func safeArrayGetVartype(safearray *SafeArray) (uint16, error) {
return uint16(0), NewError(E_NOTIMPL)
}
// safeArrayLock locks SafeArray for reading to modify SafeArray.
//
// This must be called during some calls to ensure that another process does not
// read or write to the SafeArray during editing.
//
// AKA: SafeArrayLock in Windows API.
func safeArrayLock(safearray *SafeArray) error {
return NewError(E_NOTIMPL)
}
// safeArrayUnlock unlocks SafeArray for reading.
//
// AKA: SafeArrayUnlock in Windows API.
func safeArrayUnlock(safearray *SafeArray) error {
return NewError(E_NOTIMPL)
}
// safeArrayPutElement stores the data element at the specified location in the
// array.
//
// AKA: SafeArrayPutElement in Windows API.
func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) error {
return NewError(E_NOTIMPL)
}
// safeArrayGetRecordInfo accesses IRecordInfo info for custom types.
//
// AKA: SafeArrayGetRecordInfo in Windows API.
//
// XXX: Must implement IRecordInfo interface for this to return.
func safeArrayGetRecordInfo(safearray *SafeArray) (interface{}, error) {
return nil, NewError(E_NOTIMPL)
}
// safeArraySetRecordInfo mutates IRecordInfo info for custom types.
//
// AKA: SafeArraySetRecordInfo in Windows API.
//
// XXX: Must implement IRecordInfo interface for this to return.
func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) error {
return NewError(E_NOTIMPL)
}

108
gosuper/vendor/github.com/go-ole/go-ole/safearray_test.go generated vendored
View File

@ -1,108 +0,0 @@
package ole
// This tests more than one function. It tests all of the functions needed in
// order to retrieve an SafeArray populated with Strings.
func Example_safeArrayGetElementString() {
CoInitialize(0)
defer CoUninitialize()
clsid, err := CLSIDFromProgID("QBXMLRP2.RequestProcessor.1")
if err != nil {
if err.(*OleError).Code() == CO_E_CLASSSTRING {
return
}
}
unknown, err := CreateInstance(clsid, IID_IUnknown)
if err != nil {
return
}
defer unknown.Release()
dispatch, err := unknown.QueryInterface(IID_IDispatch)
if err != nil {
return
}
var dispid []int32
dispid, err = dispatch.GetIDsOfName([]string{"OpenConnection2"})
if err != nil {
return
}
var result *VARIANT
_, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, "", "Test Application 1", 1)
if err != nil {
return
}
dispid, err = dispatch.GetIDsOfName([]string{"BeginSession"})
if err != nil {
return
}
result, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, "", 2)
if err != nil {
return
}
ticket := result.ToString()
dispid, err = dispatch.GetIDsOfName([]string{"QBXMLVersionsForSession"})
if err != nil {
return
}
result, err = dispatch.Invoke(dispid[0], DISPATCH_PROPERTYGET, ticket)
if err != nil {
return
}
// Where the real tests begin.
var qbXMLVersions *SafeArray
var qbXmlVersionStrings []string
qbXMLVersions = result.ToArray().Array
// Get array bounds
var LowerBounds int64
var UpperBounds int64
LowerBounds, err = safeArrayGetLBound(qbXMLVersions, 1)
if err != nil {
return
}
UpperBounds, err = safeArrayGetUBound(qbXMLVersions, 1)
if err != nil {
return
}
totalElements := UpperBounds - LowerBounds + 1
qbXmlVersionStrings = make([]string, totalElements)
for i := int64(0); i < totalElements; i++ {
qbXmlVersionStrings[int32(i)], _ = safeArrayGetElementString(qbXMLVersions, i)
}
// Release Safe Array memory
safeArrayDestroy(qbXMLVersions)
dispid, err = dispatch.GetIDsOfName([]string{"EndSession"})
if err != nil {
return
}
_, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, ticket)
if err != nil {
return
}
dispid, err = dispatch.GetIDsOfName([]string{"CloseConnection"})
if err != nil {
return
}
_, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD)
if err != nil {
return
}
}

337
gosuper/vendor/github.com/go-ole/go-ole/safearray_windows.go generated vendored
View File

@ -1,337 +0,0 @@
// +build windows
package ole
import (
"unsafe"
)
var (
procSafeArrayAccessData, _ = modoleaut32.FindProc("SafeArrayAccessData")
procSafeArrayAllocData, _ = modoleaut32.FindProc("SafeArrayAllocData")
procSafeArrayAllocDescriptor, _ = modoleaut32.FindProc("SafeArrayAllocDescriptor")
procSafeArrayAllocDescriptorEx, _ = modoleaut32.FindProc("SafeArrayAllocDescriptorEx")
procSafeArrayCopy, _ = modoleaut32.FindProc("SafeArrayCopy")
procSafeArrayCopyData, _ = modoleaut32.FindProc("SafeArrayCopyData")
procSafeArrayCreate, _ = modoleaut32.FindProc("SafeArrayCreate")
procSafeArrayCreateEx, _ = modoleaut32.FindProc("SafeArrayCreateEx")
procSafeArrayCreateVector, _ = modoleaut32.FindProc("SafeArrayCreateVector")
procSafeArrayCreateVectorEx, _ = modoleaut32.FindProc("SafeArrayCreateVectorEx")
procSafeArrayDestroy, _ = modoleaut32.FindProc("SafeArrayDestroy")
procSafeArrayDestroyData, _ = modoleaut32.FindProc("SafeArrayDestroyData")
procSafeArrayDestroyDescriptor, _ = modoleaut32.FindProc("SafeArrayDestroyDescriptor")
procSafeArrayGetDim, _ = modoleaut32.FindProc("SafeArrayGetDim")
procSafeArrayGetElement, _ = modoleaut32.FindProc("SafeArrayGetElement")
procSafeArrayGetElemsize, _ = modoleaut32.FindProc("SafeArrayGetElemsize")
procSafeArrayGetIID, _ = modoleaut32.FindProc("SafeArrayGetIID")
procSafeArrayGetLBound, _ = modoleaut32.FindProc("SafeArrayGetLBound")
procSafeArrayGetUBound, _ = modoleaut32.FindProc("SafeArrayGetUBound")
procSafeArrayGetVartype, _ = modoleaut32.FindProc("SafeArrayGetVartype")
procSafeArrayLock, _ = modoleaut32.FindProc("SafeArrayLock")
procSafeArrayPtrOfIndex, _ = modoleaut32.FindProc("SafeArrayPtrOfIndex")
procSafeArrayUnaccessData, _ = modoleaut32.FindProc("SafeArrayUnaccessData")
procSafeArrayUnlock, _ = modoleaut32.FindProc("SafeArrayUnlock")
procSafeArrayPutElement, _ = modoleaut32.FindProc("SafeArrayPutElement")
//procSafeArrayRedim, _ = modoleaut32.FindProc("SafeArrayRedim") // TODO
//procSafeArraySetIID, _ = modoleaut32.FindProc("SafeArraySetIID") // TODO
procSafeArrayGetRecordInfo, _ = modoleaut32.FindProc("SafeArrayGetRecordInfo")
procSafeArraySetRecordInfo, _ = modoleaut32.FindProc("SafeArraySetRecordInfo")
)
// safeArrayAccessData returns raw array pointer.
//
// AKA: SafeArrayAccessData in Windows API.
// Todo: Test
func safeArrayAccessData(safearray *SafeArray) (element uintptr, err error) {
err = convertHresultToError(
procSafeArrayAccessData.Call(
uintptr(unsafe.Pointer(safearray)),
uintptr(unsafe.Pointer(&element))))
return
}
// safeArrayUnaccessData releases raw array.
//
// AKA: SafeArrayUnaccessData in Windows API.
func safeArrayUnaccessData(safearray *SafeArray) (err error) {
err = convertHresultToError(procSafeArrayUnaccessData.Call(uintptr(unsafe.Pointer(safearray))))
return
}
// safeArrayAllocData allocates SafeArray.
//
// AKA: SafeArrayAllocData in Windows API.
func safeArrayAllocData(safearray *SafeArray) (err error) {
err = convertHresultToError(procSafeArrayAllocData.Call(uintptr(unsafe.Pointer(safearray))))
return
}
// safeArrayAllocDescriptor allocates SafeArray.
//
// AKA: SafeArrayAllocDescriptor in Windows API.
func safeArrayAllocDescriptor(dimensions uint32) (safearray *SafeArray, err error) {
err = convertHresultToError(
procSafeArrayAllocDescriptor.Call(uintptr(dimensions), uintptr(unsafe.Pointer(&safearray))))
return
}
// safeArrayAllocDescriptorEx allocates SafeArray.
//
// AKA: SafeArrayAllocDescriptorEx in Windows API.
func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (safearray *SafeArray, err error) {
err = convertHresultToError(
procSafeArrayAllocDescriptorEx.Call(
uintptr(variantType),
uintptr(dimensions),
uintptr(unsafe.Pointer(&safearray))))
return
}
// safeArrayCopy returns copy of SafeArray.
//
// AKA: SafeArrayCopy in Windows API.
func safeArrayCopy(original *SafeArray) (safearray *SafeArray, err error) {
err = convertHresultToError(
procSafeArrayCopy.Call(
uintptr(unsafe.Pointer(original)),
uintptr(unsafe.Pointer(&safearray))))
return
}
// safeArrayCopyData duplicates SafeArray into another SafeArray object.
//
// AKA: SafeArrayCopyData in Windows API.
func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) (err error) {
err = convertHresultToError(
procSafeArrayCopyData.Call(
uintptr(unsafe.Pointer(original)),
uintptr(unsafe.Pointer(duplicate))))
return
}
// safeArrayCreate creates SafeArray.
//
// AKA: SafeArrayCreate in Windows API.
func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (safearray *SafeArray, err error) {
sa, _, err := procSafeArrayCreate.Call(
uintptr(variantType),
uintptr(dimensions),
uintptr(unsafe.Pointer(bounds)))
safearray = (*SafeArray)(unsafe.Pointer(&sa))
return
}
// safeArrayCreateEx creates SafeArray.
//
// AKA: SafeArrayCreateEx in Windows API.
func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (safearray *SafeArray, err error) {
sa, _, err := procSafeArrayCreateEx.Call(
uintptr(variantType),
uintptr(dimensions),
uintptr(unsafe.Pointer(bounds)),
extra)
safearray = (*SafeArray)(unsafe.Pointer(sa))
return
}
// safeArrayCreateVector creates SafeArray.
//
// AKA: SafeArrayCreateVector in Windows API.
func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (safearray *SafeArray, err error) {
sa, _, err := procSafeArrayCreateVector.Call(
uintptr(variantType),
uintptr(lowerBound),
uintptr(length))
safearray = (*SafeArray)(unsafe.Pointer(sa))
return
}
// safeArrayCreateVectorEx creates SafeArray.
//
// AKA: SafeArrayCreateVectorEx in Windows API.
func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (safearray *SafeArray, err error) {
sa, _, err := procSafeArrayCreateVectorEx.Call(
uintptr(variantType),
uintptr(lowerBound),
uintptr(length),
extra)
safearray = (*SafeArray)(unsafe.Pointer(sa))
return
}
// safeArrayDestroy destroys SafeArray object.
//
// AKA: SafeArrayDestroy in Windows API.
func safeArrayDestroy(safearray *SafeArray) (err error) {
err = convertHresultToError(procSafeArrayDestroy.Call(uintptr(unsafe.Pointer(safearray))))
return
}
// safeArrayDestroyData destroys SafeArray object.
//
// AKA: SafeArrayDestroyData in Windows API.
func safeArrayDestroyData(safearray *SafeArray) (err error) {
err = convertHresultToError(procSafeArrayDestroyData.Call(uintptr(unsafe.Pointer(safearray))))
return
}
// safeArrayDestroyDescriptor destroys SafeArray object.
//
// AKA: SafeArrayDestroyDescriptor in Windows API.
func safeArrayDestroyDescriptor(safearray *SafeArray) (err error) {
err = convertHresultToError(procSafeArrayDestroyDescriptor.Call(uintptr(unsafe.Pointer(safearray))))
return
}
// safeArrayGetDim is the amount of dimensions in the SafeArray.
//
// SafeArrays may have multiple dimensions. Meaning, it could be
// multidimensional array.
//
// AKA: SafeArrayGetDim in Windows API.
func safeArrayGetDim(safearray *SafeArray) (dimensions *uint32, err error) {
l, _, err := procSafeArrayGetDim.Call(uintptr(unsafe.Pointer(safearray)))
dimensions = (*uint32)(unsafe.Pointer(l))
return
}
// safeArrayGetElementSize is the element size in bytes.
//
// AKA: SafeArrayGetElemsize in Windows API.
func safeArrayGetElementSize(safearray *SafeArray) (length *uint32, err error) {
l, _, err := procSafeArrayGetElemsize.Call(uintptr(unsafe.Pointer(safearray)))
length = (*uint32)(unsafe.Pointer(l))
return
}
// safeArrayGetElement retrieves element at given index.
func safeArrayGetElement(safearray *SafeArray, index int64, pv unsafe.Pointer) error {
return convertHresultToError(
procSafeArrayGetElement.Call(
uintptr(unsafe.Pointer(safearray)),
uintptr(unsafe.Pointer(&index)),
uintptr(pv)))
}
// safeArrayGetElementString retrieves element at given index and converts to string.
func safeArrayGetElementString(safearray *SafeArray, index int64) (str string, err error) {
var element *int16
err = convertHresultToError(
procSafeArrayGetElement.Call(
uintptr(unsafe.Pointer(safearray)),
uintptr(unsafe.Pointer(&index)),
uintptr(unsafe.Pointer(&element))))
str = BstrToString(*(**uint16)(unsafe.Pointer(&element)))
SysFreeString(element)
return
}
// safeArrayGetIID is the InterfaceID of the elements in the SafeArray.
//
// AKA: SafeArrayGetIID in Windows API.
func safeArrayGetIID(safearray *SafeArray) (guid *GUID, err error) {
err = convertHresultToError(
procSafeArrayGetIID.Call(
uintptr(unsafe.Pointer(safearray)),
uintptr(unsafe.Pointer(&guid))))
return
}
// safeArrayGetLBound returns lower bounds of SafeArray.
//
// SafeArrays may have multiple dimensions. Meaning, it could be
// multidimensional array.
//
// AKA: SafeArrayGetLBound in Windows API.
func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (lowerBound int64, err error) {
err = convertHresultToError(
procSafeArrayGetLBound.Call(
uintptr(unsafe.Pointer(safearray)),
uintptr(dimension),
uintptr(unsafe.Pointer(&lowerBound))))
return
}
// safeArrayGetUBound returns upper bounds of SafeArray.
//
// SafeArrays may have multiple dimensions. Meaning, it could be
// multidimensional array.
//
// AKA: SafeArrayGetUBound in Windows API.
func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (upperBound int64, err error) {
err = convertHresultToError(
procSafeArrayGetUBound.Call(
uintptr(unsafe.Pointer(safearray)),
uintptr(dimension),
uintptr(unsafe.Pointer(&upperBound))))
return
}
// safeArrayGetVartype returns data type of SafeArray.
//
// AKA: SafeArrayGetVartype in Windows API.
func safeArrayGetVartype(safearray *SafeArray) (varType uint16, err error) {
err = convertHresultToError(
procSafeArrayGetVartype.Call(
uintptr(unsafe.Pointer(safearray)),
uintptr(unsafe.Pointer(&varType))))
return
}
// safeArrayLock locks SafeArray for reading to modify SafeArray.
//
// This must be called during some calls to ensure that another process does not
// read or write to the SafeArray during editing.
//
// AKA: SafeArrayLock in Windows API.
func safeArrayLock(safearray *SafeArray) (err error) {
err = convertHresultToError(procSafeArrayLock.Call(uintptr(unsafe.Pointer(safearray))))
return
}
// safeArrayUnlock unlocks SafeArray for reading.
//
// AKA: SafeArrayUnlock in Windows API.
func safeArrayUnlock(safearray *SafeArray) (err error) {
err = convertHresultToError(procSafeArrayUnlock.Call(uintptr(unsafe.Pointer(safearray))))
return
}
// safeArrayPutElement stores the data element at the specified location in the
// array.
//
// AKA: SafeArrayPutElement in Windows API.
func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) (err error) {
err = convertHresultToError(
procSafeArrayPutElement.Call(
uintptr(unsafe.Pointer(safearray)),
uintptr(unsafe.Pointer(&index)),
uintptr(unsafe.Pointer(element))))
return
}
// safeArrayGetRecordInfo accesses IRecordInfo info for custom types.
//
// AKA: SafeArrayGetRecordInfo in Windows API.
//
// XXX: Must implement IRecordInfo interface for this to return.
func safeArrayGetRecordInfo(safearray *SafeArray) (recordInfo interface{}, err error) {
err = convertHresultToError(
procSafeArrayGetRecordInfo.Call(
uintptr(unsafe.Pointer(safearray)),
uintptr(unsafe.Pointer(&recordInfo))))
return
}
// safeArraySetRecordInfo mutates IRecordInfo info for custom types.
//
// AKA: SafeArraySetRecordInfo in Windows API.
//
// XXX: Must implement IRecordInfo interface for this to return.
func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) (err error) {
err = convertHresultToError(
procSafeArraySetRecordInfo.Call(
uintptr(unsafe.Pointer(safearray)),
uintptr(unsafe.Pointer(&recordInfo))))
return
}

140
gosuper/vendor/github.com/go-ole/go-ole/safearrayconversion.go generated vendored
View File

@ -1,140 +0,0 @@
// Helper for converting SafeArray to array of objects.
package ole
import (
"unsafe"
)
type SafeArrayConversion struct {
Array *SafeArray
}
func (sac *SafeArrayConversion) ToStringArray() (strings []string) {
totalElements, _ := sac.TotalElements(0)
strings = make([]string, totalElements)
for i := int64(0); i < totalElements; i++ {
strings[int32(i)], _ = safeArrayGetElementString(sac.Array, i)
}
return
}
func (sac *SafeArrayConversion) ToByteArray() (bytes []byte) {
totalElements, _ := sac.TotalElements(0)
bytes = make([]byte, totalElements)
for i := int64(0); i < totalElements; i++ {
safeArrayGetElement(sac.Array, i, unsafe.Pointer(&bytes[int32(i)]))
}
return
}
func (sac *SafeArrayConversion) ToValueArray() (values []interface{}) {
totalElements, _ := sac.TotalElements(0)
values = make([]interface{}, totalElements)
vt, _ := safeArrayGetVartype(sac.Array)
for i := 0; i < int(totalElements); i++ {
switch VT(vt) {
case VT_BOOL:
var v bool
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_I1:
var v int8
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_I2:
var v int16
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_I4:
var v int32
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_I8:
var v int64
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_UI1:
var v uint8
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_UI2:
var v uint16
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_UI4:
var v uint32
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_UI8:
var v uint64
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_R4:
var v float32
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_R8:
var v float64
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_BSTR:
var v string
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v
case VT_VARIANT:
var v VARIANT
safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
values[i] = v.Value()
default:
// TODO
}
}
return
}
func (sac *SafeArrayConversion) GetType() (varType uint16, err error) {
return safeArrayGetVartype(sac.Array)
}
func (sac *SafeArrayConversion) GetDimensions() (dimensions *uint32, err error) {
return safeArrayGetDim(sac.Array)
}
func (sac *SafeArrayConversion) GetSize() (length *uint32, err error) {
return safeArrayGetElementSize(sac.Array)
}
func (sac *SafeArrayConversion) TotalElements(index uint32) (totalElements int64, err error) {
if index < 1 {
index = 1
}
// Get array bounds
var LowerBounds int64
var UpperBounds int64
LowerBounds, err = safeArrayGetLBound(sac.Array, index)
if err != nil {
return
}
UpperBounds, err = safeArrayGetUBound(sac.Array, index)
if err != nil {
return
}
totalElements = UpperBounds - LowerBounds + 1
return
}
// Release Safe Array memory
func (sac *SafeArrayConversion) Release() {
safeArrayDestroy(sac.Array)
}

119
gosuper/vendor/github.com/go-ole/go-ole/safearrayconversion_test.go generated vendored
View File

@ -1,119 +0,0 @@
// +build windows
package ole
import (
"fmt"
"strings"
"testing"
)
// This tests more than one function. It tests all of the functions needed in order to retrieve an
// SafeArray populated with Strings.
func TestSafeArrayConversionString(t *testing.T) {
CoInitialize(0)
defer CoUninitialize()
clsid, err := CLSIDFromProgID("QBXMLRP2.RequestProcessor.1")
if err != nil {
if err.(*OleError).Code() == CO_E_CLASSSTRING {
return
}
t.Log(err)
t.FailNow()
}
unknown, err := CreateInstance(clsid, IID_IUnknown)
if err != nil {
t.Log(err)
t.FailNow()
}
defer unknown.Release()
dispatch, err := unknown.QueryInterface(IID_IDispatch)
if err != nil {
t.Log(err)
t.FailNow()
}
var dispid []int32
dispid, err = dispatch.GetIDsOfName([]string{"OpenConnection2"})
if err != nil {
t.Log(err)
t.FailNow()
}
var result *VARIANT
_, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, "", "Test Application 1", 1)
if err != nil {
t.Log(err)
t.FailNow()
}
dispid, err = dispatch.GetIDsOfName([]string{"BeginSession"})
if err != nil {
t.Log(err)
t.FailNow()
}
result, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, "", 2)
if err != nil {
t.Log(err)
t.FailNow()
}
ticket := result.ToString()
dispid, err = dispatch.GetIDsOfName([]string{"QBXMLVersionsForSession"})
if err != nil {
t.Log(err)
t.FailNow()
}
result, err = dispatch.Invoke(dispid[0], DISPATCH_PROPERTYGET, ticket)
if err != nil {
t.Log(err)
t.FailNow()
}
// Where the real tests begin.
conversion := result.ToArray()
totalElements, _ := conversion.TotalElements(0)
if totalElements != 13 {
t.Log(fmt.Sprintf("%d total elements does not equal 13\n", totalElements))
t.Fail()
}
versions := conversion.ToStringArray()
if len(versions) != 13 {
t.Log(fmt.Sprintf("%s\n", strings.Join(versions, ", ")))
t.Fail()
}
conversion.Release()
dispid, err = dispatch.GetIDsOfName([]string{"EndSession"})
if err != nil {
t.Log(err)
t.FailNow()
}
_, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD, ticket)
if err != nil {
t.Log(err)
t.FailNow()
}
dispid, err = dispatch.GetIDsOfName([]string{"CloseConnection"})
if err != nil {
t.Log(err)
t.FailNow()
}
_, err = dispatch.Invoke(dispid[0], DISPATCH_METHOD)
if err != nil {
t.Log(err)
t.FailNow()
}
}

33
gosuper/vendor/github.com/go-ole/go-ole/safearrayslices.go generated vendored
View File

@ -1,33 +0,0 @@
// +build windows
package ole
import (
"unsafe"
)
func safeArrayFromByteSlice(slice []byte) *SafeArray {
array, _ := safeArrayCreateVector(VT_UI1, 0, uint32(len(slice)))
if array == nil {
panic("Could not convert []byte to SAFEARRAY")
}
for i, v := range slice {
safeArrayPutElement(array, int64(i), uintptr(unsafe.Pointer(&v)))
}
return array
}
func safeArrayFromStringSlice(slice []string) *SafeArray {
array, _ := safeArrayCreateVector(VT_BSTR, 0, uint32(len(slice)))
if array == nil {
panic("Could not convert []string to SAFEARRAY")
}
// SysAllocStringLen(s)
for i, v := range slice {
safeArrayPutElement(array, int64(i), uintptr(unsafe.Pointer(SysAllocStringLen(v))))
}
return array
}

Some files were not shown because too many files have changed in this diff Show More