1

diff --git a/linuxwin/darwin.go b/linuxwin/darwin.go
new file mode 100644 (file)
index 0000000..3f38dd6
--- /dev/null
+++ b/linuxwin/darwin.go
@@ -0,0 +1,88 @@
+//go:build darwin
+// +build darwin
+
+package Ppart
+
+import (
+       "os"
+       "os/exec"
+       "path/filepath"
+       "strconv"
+       "strings"
+
+       signal "github.com/qydysky/part/signal"
+)
+
+func PCheck(pros []string) []int {
+       res := []int{}
+       _pros := [][]byte{}
+
+       for _, v := range pros {
+               if v == "" {
+                       return res
+               }
+               _pros = append(_pros, []byte(v))
+               res = append(res, 0)
+       }
+
+       for j, i := range _pros {
+               cmd := exec.Command("pgrep", "-c", string(i))
+               output, _ := cmd.Output()
+               outputt := strings.Replace(string(output), "\n", "", -1)
+               res[j], _ = strconv.Atoi(outputt)
+       }
+       return res
+}
+
+func PStartf(pro []*exec.Cmd) {
+       for i := range pro {
+               pro[i].Start()
+       }
+}
+
+func PRun(hide bool, prog string, cmd ...string) error {
+       p := exec.Command(prog, cmd...)
+       if hide {
+       }
+       e := p.Run()
+       return e
+}
+
+func Cdir() string {
+       dir, _ := os.Executable()
+       exPath := filepath.Dir(dir)
+       return exPath
+}
+
+func PProxy(s, pacUrl string) error {
+       if s == "off" {
+               if e := PRun(true, "gsettings", "set", "org.gnome.system.proxy", "mode", "none"); e != nil {
+                       return e
+               }
+               if e := PRun(true, "kwriteconfig5", "--file", "kioslaverc", "--group", "Proxy Settings", "--key", "ProxyType", "0"); e != nil {
+                       return e
+               }
+       } else {
+               if e := PRun(true, "gsettings", "set", "org.gnome.system.proxy", "autoconfig-url", pacUrl); e != nil {
+                       return e
+               }
+               if e := PRun(true, "gsettings", "set", "org.gnome.system.proxy", "mode", "auto"); e != nil {
+                       return e
+               }
+               if e := PRun(true, "kwriteconfig5", "--file", "kioslaverc", "--group", "Proxy Settings", "--key", "ProxyType", "2"); e != nil {
+                       return e
+               }
+               if e := PRun(true, "kwriteconfig5", "--file", "kioslaverc", "--group", "Proxy Settings", "--key", "Proxy Config Script", pacUrl); e != nil {
+                       return e
+               }
+       }
+       return nil
+}
+
+func FileMove(src, trg string) error {
+       return os.Rename(src, trg)
+}
+
+func PreventSleep() (stop *signal.Signal) {
+       return nil
+}

diff --git a/linuxwin/none.go b/linuxwin/none.go
new file mode 100644 (file)
index 0000000..37c7600
--- /dev/null
+++ b/linuxwin/none.go
@@ -0,0 +1,48 @@
+//go:build !darwin && !linux && !windows
+// +build !darwin,!linux,!windows
+
+package Ppart
+
+import (
+       "os"
+       "os/exec"
+       "path/filepath"
+
+       signal "github.com/qydysky/part/signal"
+)
+
+func PCheck(pros []string) []int {
+       return []int{}
+}
+
+func PStartf(pro []*exec.Cmd) {
+       for i := range pro {
+               pro[i].Start()
+       }
+}
+
+func PRun(hide bool, prog string, cmd ...string) error {
+       p := exec.Command(prog, cmd...)
+       if hide {
+       }
+       e := p.Run()
+       return e
+}
+
+func Cdir() string {
+       dir, _ := os.Executable()
+       exPath := filepath.Dir(dir)
+       return exPath
+}
+
+func PProxy(s, pacUrl string) error {
+       return nil
+}
+
+func FileMove(src, trg string) error {
+       return os.Rename(src, trg)
+}
+
+func PreventSleep() (stop *signal.Signal) {
+       return nil
+}

diff --git a/linuxwin/win.go b/linuxwin/win.go
index ed1ae78f55d0857c9b29f7f04fed28e7c3d63bf4..804cf678eff6e6ab184d619b8a6e18944b95f9b0 100755 (executable)
--- a/linuxwin/win.go
+++ b/linuxwin/win.go
@@ -1,5 +1,5 @@
-//go:build !linux
-// +build !linux
+//go:build windows
+// +build windows
 
 package Ppart
 

diff --git a/rpc/Rpc.go b/rpc/Rpc.go
index f2add444f26209a4980bf49422bed895c09a1699..974875429a85a6ef1ded1d6a830f22a8cd26f594 100644 (file)
--- a/rpc/Rpc.go
+++ b/rpc/Rpc.go
@@ -120,7 +120,7 @@ func UnRegister(t *Server, path string) {
        t.webP.Store(path, nil)
 }
 
-func Call[T, E any](it *T, ot *E, host, path string) error {
+func Call[T, E any](host, path string, it *T, ot *E) error {
        var buf bytes.Buffer
        if e := gob.NewEncoder(&buf).Encode(it); e != nil {
                return errors.Join(ErrCliEncode, e)
@@ -143,3 +143,86 @@ func Call[T, E any](it *T, ot *E, host, path string) error {
                }
        }
 }
+
+// var (
+//     ErrRegUnKnowMethod = errors.New("ErrRegUnKnowMethod")
+// )
+
+// type RegisterSer struct {
+//     m        map[string]*registerItem
+//     Shutdown func(ctx ...context.Context)
+//     sync.RWMutex
+// }
+
+// type RegisterSerHost struct {
+//     Act  string
+//     Host string
+//     Path string
+// }
+
+// type registerItem struct {
+//     hosts map[string]struct{}
+//     sync.RWMutex
+// }
+
+// func NewRegisterSer(host, path string) (ser *RegisterSer, e error) {
+//     ser = &RegisterSer{m: make(map[string]*registerItem)}
+//     s := NewServer(host)
+//     ser.Shutdown = s.Shutdown
+//     e = Register(s, path, func(it *RegisterSerHost, ot *struct{}) error {
+//             if it.Act == "add" {
+//                     ser.RLock()
+//                     item, ok := ser.m[it.Path]
+//                     ser.RUnlock()
+//                     if ok {
+//                             item.Lock()
+//                             item.hosts[it.Host] = struct{}{}
+//                             item.Unlock()
+//                     } else {
+//                             ser.Lock()
+//                             l := make(map[string]struct{})
+//                             l[it.Host] = struct{}{}
+//                             ser.m[it.Path] = &registerItem{
+//                                     hosts: l,
+//                             }
+//                             ser.Unlock()
+//                     }
+//             } else if it.Act == "del" {
+//                     ser.RLock()
+//                     item, ok := ser.m[it.Path]
+//                     ser.RUnlock()
+//                     if ok {
+//                             item.Lock()
+//                             delete(item.hosts, it.Host)
+//                             item.Unlock()
+//                     }
+//             } else {
+//                     return ErrRegUnKnowMethod
+//             }
+//             return nil
+//     })
+//     return
+// }
+
+// func RegisterSerReg(regHost, regPath string, info RegisterSerHost) error {
+//     return Call(&info, &struct{}{}, regHost, regPath)
+// }
+
+// func RegisterSerCall[T any](ser *RegisterSer, it *T, path string) {
+//     ser.RLock()
+//     item, ok := ser.m[path]
+//     ser.RUnlock()
+//     if ok {
+//             var hosts []string
+//             item.RLock()
+//             for host, _ := range item.hosts {
+//                     hosts = append(hosts, host)
+//             }
+//             item.RUnlock()
+
+//             for len(hosts) > 0 {
+//                     _ = Call(it, &struct{}{}, hosts[0], path)
+//                     hosts = hosts[1:]
+//             }
+//     }
+// }

diff --git a/rpc/Rpc_test.go b/rpc/Rpc_test.go
index 247830c8752be6c799fa161eafdefb59c1645402..69342a684be31c24ae3d8d6e5d1e2dab2da977be 100644 (file)
--- a/rpc/Rpc_test.go
+++ b/rpc/Rpc_test.go
@@ -35,7 +35,7 @@ func TestMain(t *testing.T) {
        var i int = 9
        var out test2
 
-       if e := Call(&i, &out, "127.0.0.1:10902", "/123"); e != nil {
+       if e := Call("127.0.0.1:10902", "/123", &i, &out); e != nil {
                t.Fatal(e)
        }
 
@@ -43,3 +43,55 @@ func TestMain(t *testing.T) {
                t.FailNow()
        }
 }
+
+// func TestMain2(t *testing.T) {
+
+//     pob := NewServer("127.0.0.1:10902")
+//     defer pob.Shutdown()
+//     if e := Register(pob, "/123", func(i *int, o *struct{}) error {
+//             if *i == 9 || *i == 10 {
+//                     t.FailNow()
+//             }
+//             return errors.New("")
+//     }); e != nil {
+//             t.Fatal(e)
+//     }
+
+//     pob2 := NewServer("127.0.0.1:10903")
+//     defer pob2.Shutdown()
+//     if e := Register(pob2, "/123", func(i *int, o *struct{}) error {
+
+//             if e := RegisterSerReg("127.0.0.1:10992", "/", RegisterSerHost{"del", "127.0.0.1:10903", "/123"}); e != nil {
+//                     t.Fatal(e)
+//             }
+
+//             if *i == 9 {
+//                     t.FailNow()
+//             }
+//             return errors.New("")
+//     }); e != nil {
+//             t.Fatal(e)
+//     }
+
+//     regs, e := NewRegisterSer("127.0.0.1:10992", "/")
+//     if e != nil {
+//             t.Fatal(e)
+//     } else {
+//             defer regs.Shutdown()
+//     }
+
+//     if e := RegisterSerReg("127.0.0.1:10992", "/", RegisterSerHost{"add", "127.0.0.1:10902", "/123"}); e != nil {
+//             t.Fatal(e)
+//     }
+//     if e := RegisterSerReg("127.0.0.1:10992", "/", RegisterSerHost{"add", "127.0.0.1:10903", "/123"}); e != nil {
+//             t.Fatal(e)
+//     }
+
+//     var i int = 9
+
+//     RegisterSerCall(regs, &i, "/123")
+
+//     i++
+
+//     RegisterSerCall(regs, &i, "/123")
+// }