feat: save several servers and pick one to connect
Match the first-party mobile client's connection screen: - the first screen lists saved servers, the one last used leading with its connect button or connected state, the others below, and adding is one tap - servers can be added, edited (name, address, proxy, self-signed) and deleted; deleting the live or last one returns to the list - a password sheet prompts only when the server asks for one, keeps the error and the typed password for a retry - while connected, the instances sheet switches servers - proxy and self-signed options stay per server (the native app's own) - the single-server record and its token migrate automatically - permission cards read a plain signal, fixing a flaky update - bump version to 0.1.2 (build 3)
This commit is contained in:
1 parent
ef0b63ceee
commit
13aca21d99
12 files changed
+966
-361
No files matched your search
+297
-136
@@ -5,6 +5,7 @@ import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
@@ -50,20 +51,34 @@ func newApp(st storage.Store) (*controller, ui.Node) {
|
||||
type controller struct {
|
||||
st storage.Store
|
||||
|
||||
connections *signal.Signal[[]storage.Connection]
|
||||
|
||||
url *signal.Signal[string]
|
||||
password *signal.Signal[string]
|
||||
useProxy *signal.Signal[bool]
|
||||
proxy *signal.Signal[string]
|
||||
insecure *signal.Signal[bool]
|
||||
status *signal.Signal[string]
|
||||
errorMsg *signal.Signal[string]
|
||||
|
||||
server *signal.Signal[string]
|
||||
connected *signal.Signal[bool]
|
||||
busy *signal.Signal[bool]
|
||||
sessions *signal.Signal[[]ocapi.Session]
|
||||
active *signal.Signal[map[string]bool]
|
||||
perms *signal.Signal[[]ocapi.PermissionRequest]
|
||||
formOpen *signal.Signal[bool]
|
||||
formEditID string
|
||||
formLabel *signal.Signal[string]
|
||||
formUseProxy *signal.Signal[bool]
|
||||
formProxy *signal.Signal[string]
|
||||
formInsecure *signal.Signal[bool]
|
||||
|
||||
passwordOpen *signal.Signal[bool]
|
||||
passwordFor storage.Connection
|
||||
passwordText *signal.Signal[string]
|
||||
passwordBusy *signal.Signal[bool]
|
||||
|
||||
instancesOpen *signal.Signal[bool]
|
||||
|
||||
server *signal.Signal[string]
|
||||
connected *signal.Signal[bool]
|
||||
busy *signal.Signal[bool]
|
||||
connecting *signal.Signal[string]
|
||||
activeID *signal.Signal[string]
|
||||
sessions *signal.Signal[[]ocapi.Session]
|
||||
active *signal.Signal[map[string]bool]
|
||||
perms *signal.Signal[[]ocapi.PermissionRequest]
|
||||
defaultDir *signal.Signal[string]
|
||||
|
||||
newOpen *signal.Signal[bool]
|
||||
@@ -78,45 +93,54 @@ type controller struct {
|
||||
}
|
||||
|
||||
func newController(st storage.Store) *controller {
|
||||
conns := st.Connections()
|
||||
sort.SliceStable(conns, func(i, j int) bool { return conns[i].LastUsedAt > conns[j].LastUsedAt })
|
||||
c := &controller{
|
||||
st: st,
|
||||
url: signal.New(""),
|
||||
password: signal.New(""),
|
||||
useProxy: signal.New(false),
|
||||
proxy: signal.New(""),
|
||||
insecure: signal.New(false),
|
||||
status: signal.New("输入服务器地址与密码后连接"),
|
||||
server: signal.New(""),
|
||||
connected: signal.New(false),
|
||||
busy: signal.New(false),
|
||||
sessions: signal.NewFunc([]ocapi.Session{}, nil),
|
||||
active: signal.NewFunc(map[string]bool{}, nil),
|
||||
perms: signal.NewFunc([]ocapi.PermissionRequest{}, nil),
|
||||
defaultDir: signal.New(""),
|
||||
newOpen: signal.New(false),
|
||||
newTitle: signal.New(""),
|
||||
newDir: signal.New(0),
|
||||
creating: signal.New(false),
|
||||
st: st,
|
||||
connections: signal.NewFunc(conns, nil),
|
||||
url: signal.New(""),
|
||||
status: signal.New(""),
|
||||
errorMsg: signal.New(""),
|
||||
formOpen: signal.New(false),
|
||||
formLabel: signal.New(""),
|
||||
formUseProxy: signal.New(false),
|
||||
formProxy: signal.New(""),
|
||||
formInsecure: signal.New(false),
|
||||
passwordOpen: signal.New(false),
|
||||
passwordText: signal.New(""),
|
||||
passwordBusy: signal.New(false),
|
||||
instancesOpen: signal.New(false),
|
||||
server: signal.New(""),
|
||||
connected: signal.New(false),
|
||||
busy: signal.New(false),
|
||||
connecting: signal.New(""),
|
||||
activeID: signal.New(""),
|
||||
sessions: signal.NewFunc([]ocapi.Session{}, nil),
|
||||
active: signal.NewFunc(map[string]bool{}, nil),
|
||||
perms: signal.NewFunc([]ocapi.PermissionRequest{}, nil),
|
||||
defaultDir: signal.New(""),
|
||||
newOpen: signal.New(false),
|
||||
newTitle: signal.New(""),
|
||||
newDir: signal.New(0),
|
||||
creating: signal.New(false),
|
||||
}
|
||||
if conn, ok := st.Connection(); ok {
|
||||
c.url.Set(conn.URL)
|
||||
c.proxy.Set(conn.Proxy)
|
||||
c.useProxy.Set(conn.Proxy != "")
|
||||
c.insecure.Set(conn.Insecure)
|
||||
c.status.Set("正在恢复连接…")
|
||||
c.reconnect(conn)
|
||||
// Come back to the server last used, as the first-party client does.
|
||||
if len(conns) > 0 {
|
||||
c.connectTo(conns[0], "", false)
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
func (c *controller) screen() ui.Node {
|
||||
return ui.SafeArea(ui.Style{Grow: 1},
|
||||
ui.Show(c.connected, c.sessionsScreen, c.connectScreen),
|
||||
ui.Show(c.connected, c.sessionsScreen, c.connectionsScreen),
|
||||
c.formSheet(),
|
||||
c.passwordSheet(),
|
||||
c.instancesSheet(),
|
||||
c.newSessionSheetNode(),
|
||||
)
|
||||
}
|
||||
|
||||
// shutdown stops what the controller started; the root owner calls it when
|
||||
// the app (or a test) unmounts.
|
||||
func (c *controller) shutdown() {
|
||||
if c.cancelSSE != nil {
|
||||
c.cancelSSE()
|
||||
@@ -125,75 +149,42 @@ func (c *controller) shutdown() {
|
||||
c.client = nil
|
||||
}
|
||||
|
||||
func (c *controller) connect() {
|
||||
if c.busy.Peek() {
|
||||
// connectTo starts a connection attempt off the main thread. password is
|
||||
// the one the user typed, if any; explicit marks a tap (a password may be
|
||||
// asked for), while the launch reconnect stays quiet.
|
||||
func (c *controller) connectTo(conn storage.Connection, password string, explicit bool) {
|
||||
if c.connecting.Peek() != "" {
|
||||
return
|
||||
}
|
||||
params := connectParams{
|
||||
url: strings.TrimSpace(c.url.Peek()),
|
||||
password: c.password.Peek(),
|
||||
insecure: c.insecure.Peek(),
|
||||
explicit: true,
|
||||
}
|
||||
if c.useProxy.Peek() {
|
||||
params.proxy = strings.TrimSpace(c.proxy.Peek())
|
||||
}
|
||||
c.busy.Set(true)
|
||||
c.status.Set("连接中…")
|
||||
c.connecting.Set(conn.ID)
|
||||
c.errorMsg.Set("")
|
||||
go func() {
|
||||
c.establish(params, "")
|
||||
c.establish(conn, password, explicit)
|
||||
}()
|
||||
}
|
||||
|
||||
// reconnect retries a stored connection, whose token lives in secure
|
||||
// storage (readable only off the main thread).
|
||||
func (c *controller) reconnect(conn storage.Connection) {
|
||||
params := connectParams{
|
||||
url: conn.URL,
|
||||
proxy: conn.Proxy,
|
||||
insecure: conn.Insecure,
|
||||
}
|
||||
if conn.Passwordless {
|
||||
// No token was issued; the server answers without one.
|
||||
go func() { c.establish(params, "") }()
|
||||
return
|
||||
}
|
||||
go func() {
|
||||
token, ok, err := c.st.LoadToken(conn.URL)
|
||||
if err != nil || !ok {
|
||||
ui.Post(func() { c.status.Set("请重新输入密码") })
|
||||
return
|
||||
}
|
||||
c.establish(params, token)
|
||||
}()
|
||||
}
|
||||
|
||||
type connectParams struct {
|
||||
url string
|
||||
password string
|
||||
proxy string
|
||||
insecure bool
|
||||
// explicit means the user pressed Connect: a password prompt is
|
||||
// theirs to answer. A background reconnect never asks.
|
||||
explicit bool
|
||||
}
|
||||
|
||||
// establish runs the whole connect sequence off the main thread: health,
|
||||
// token probe, optional password login, first page of sessions. It reports
|
||||
// through the signals with ui.Post.
|
||||
func (c *controller) establish(p connectParams, token string) {
|
||||
// establish runs the whole connect sequence: health, token probe, optional
|
||||
// password login, first page of sessions.
|
||||
func (c *controller) establish(conn storage.Connection, password string, explicit bool) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second)
|
||||
defer cancel()
|
||||
|
||||
fail := func(err error) {
|
||||
ui.Post(func() {
|
||||
c.busy.Set(false)
|
||||
c.status.Set(friendlyError(err))
|
||||
c.connecting.Set("")
|
||||
c.errorMsg.Set(friendlyError(err))
|
||||
})
|
||||
}
|
||||
if !strings.Contains(conn.URL, "://") {
|
||||
normalized, err := ocapi.NormalizeBaseURL(conn.URL)
|
||||
if err != nil {
|
||||
fail(err)
|
||||
return
|
||||
}
|
||||
conn.URL = normalized
|
||||
}
|
||||
|
||||
opts := ocapi.Options{Proxy: p.proxy, InsecureSkipVerify: p.insecure}
|
||||
client, err := ocapi.New(p.url, opts)
|
||||
client, err := ocapi.New(conn.URL, ocapi.Options{Proxy: conn.Proxy, InsecureSkipVerify: conn.Insecure})
|
||||
if err != nil {
|
||||
fail(err)
|
||||
return
|
||||
@@ -208,48 +199,59 @@ func (c *controller) establish(p connectParams, token string) {
|
||||
return
|
||||
}
|
||||
|
||||
passwordless := false
|
||||
if token != "" {
|
||||
client.SetToken(token)
|
||||
token := ""
|
||||
if !conn.Passwordless {
|
||||
if t, ok, err := c.st.LoadToken(conn); err == nil && ok {
|
||||
token = t
|
||||
client.SetToken(t)
|
||||
}
|
||||
}
|
||||
passwordless := conn.Passwordless
|
||||
auth, authErr := client.SessionStatus(ctx)
|
||||
switch {
|
||||
case authErr == nil:
|
||||
passwordless = auth.Disabled
|
||||
case ocapi.IsUnauthorized(authErr):
|
||||
if strings.TrimSpace(p.password) == "" {
|
||||
if token != "" {
|
||||
// The stored token is no good: drop it so the next
|
||||
// attempt does not retry with it.
|
||||
server := client.BaseURL()
|
||||
go func() { _ = c.st.ClearToken(server) }()
|
||||
}
|
||||
if p.explicit {
|
||||
fail(errUnauthorized)
|
||||
if strings.TrimSpace(password) == "" {
|
||||
if explicit {
|
||||
ui.Post(func() {
|
||||
c.connecting.Set("")
|
||||
c.askPassword(conn)
|
||||
})
|
||||
} else {
|
||||
ui.Post(func() { c.status.Set("登录已失效,请输入密码重新连接") })
|
||||
ui.Post(func() {
|
||||
c.connecting.Set("")
|
||||
c.errorMsg.Set("登录已失效,请重新输入密码")
|
||||
c.askPassword(conn)
|
||||
})
|
||||
}
|
||||
if token != "" {
|
||||
go func() { _ = c.st.ClearToken(conn) }()
|
||||
}
|
||||
return
|
||||
}
|
||||
res, err := client.Login(ctx, ocapi.LoginRequest{
|
||||
Password: p.password,
|
||||
Password: password,
|
||||
DedupeKey: c.st.InstallID(),
|
||||
ClientLabel: "OpenChamber Native",
|
||||
ClientKind: "mobile",
|
||||
DevicePlatform: "android",
|
||||
})
|
||||
if err != nil {
|
||||
fail(err)
|
||||
ui.Post(func() {
|
||||
c.connecting.Set("")
|
||||
c.errorMsg.Set(friendlyError(err))
|
||||
c.passwordBusy.Set(false)
|
||||
c.passwordOpen.Set(true)
|
||||
})
|
||||
return
|
||||
}
|
||||
if res.ClientToken == "" {
|
||||
fail(errors.New("登录没有返回设备 token"))
|
||||
return
|
||||
}
|
||||
if err := c.st.SaveToken(client.BaseURL(), res.ClientToken); err != nil {
|
||||
// A token that cannot be persisted still works for this run.
|
||||
_ = err
|
||||
}
|
||||
_ = c.st.SaveToken(conn.ID, res.ClientToken)
|
||||
passwordless = false
|
||||
default:
|
||||
fail(authErr)
|
||||
return
|
||||
@@ -270,19 +272,23 @@ func (c *controller) establish(p connectParams, token string) {
|
||||
}
|
||||
perms, _ := client.PendingPermissions(ctx, "")
|
||||
|
||||
info := fmt.Sprintf("%s · OpenChamber %s", client.BaseURL(), health.OpenChamberVersion)
|
||||
info := fmt.Sprintf("%s · OpenChamber %s", c.labelOf(conn), health.OpenChamberVersion)
|
||||
if !health.IsOpenCodeReady {
|
||||
info += " · OpenCode 未就绪"
|
||||
}
|
||||
c.st.SaveConnection(storage.Connection{
|
||||
URL: client.BaseURL(),
|
||||
Proxy: p.proxy,
|
||||
Insecure: p.insecure,
|
||||
ServerID: health.ServerID,
|
||||
Passwordless: passwordless,
|
||||
})
|
||||
|
||||
conn.URL = client.BaseURL()
|
||||
if conn.Label == "" {
|
||||
conn.Label = hostOf(conn.URL)
|
||||
}
|
||||
conn.ServerID = health.ServerID
|
||||
conn.Passwordless = passwordless
|
||||
conn.LastUsedAt = time.Now().UnixMilli()
|
||||
|
||||
ui.Post(func() {
|
||||
c.connecting.Set("")
|
||||
c.saveConnection(conn)
|
||||
c.activeID.Set(conn.ID)
|
||||
c.client = client
|
||||
c.sessions.Set(page.Data)
|
||||
c.active.Set(running)
|
||||
@@ -290,12 +296,47 @@ func (c *controller) establish(p connectParams, token string) {
|
||||
c.server.Set(info)
|
||||
c.connected.Set(true)
|
||||
c.busy.Set(false)
|
||||
c.password.Set("")
|
||||
c.formOpen.Set(false)
|
||||
c.passwordOpen.Set(false)
|
||||
c.passwordText.Set("")
|
||||
c.passwordBusy.Set(false)
|
||||
c.instancesOpen.Set(false)
|
||||
c.errorMsg.Set("")
|
||||
c.status.Set(fmt.Sprintf("已连接,%d 个会话", len(page.Data)))
|
||||
c.startEvents(client, p)
|
||||
c.startEvents(client)
|
||||
})
|
||||
}
|
||||
|
||||
func (c *controller) saveConnection(conn storage.Connection) {
|
||||
conns := c.connections.Peek()
|
||||
found := false
|
||||
next := make([]storage.Connection, 0, len(conns)+1)
|
||||
for _, existing := range conns {
|
||||
if existing.ID == conn.ID {
|
||||
next = append(next, conn)
|
||||
found = true
|
||||
} else {
|
||||
next = append(next, existing)
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
if conn.ID == "" {
|
||||
conn.ID = storage.NewID()
|
||||
}
|
||||
next = append(next, conn)
|
||||
}
|
||||
sort.SliceStable(next, func(i, j int) bool { return next[i].LastUsedAt > next[j].LastUsedAt })
|
||||
c.st.SaveConnections(next)
|
||||
c.connections.Set(next)
|
||||
}
|
||||
|
||||
func (c *controller) labelOf(conn storage.Connection) string {
|
||||
if strings.TrimSpace(conn.Label) != "" {
|
||||
return conn.Label
|
||||
}
|
||||
return hostOf(conn.URL)
|
||||
}
|
||||
|
||||
func (c *controller) refresh() {
|
||||
if c.client == nil || c.busy.Peek() {
|
||||
return
|
||||
@@ -305,9 +346,6 @@ func (c *controller) refresh() {
|
||||
go func() {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
||||
defer cancel()
|
||||
if loc, err := client.Location(ctx); err == nil && loc.Directory != "" {
|
||||
ui.Post(func() { c.defaultDir.Set(loc.Directory) })
|
||||
}
|
||||
page, err := client.ListSessions(ctx, ocapi.ListSessionsOptions{Limit: 50, Order: "desc"})
|
||||
active, aerr := client.ActiveSessions(ctx)
|
||||
running := make(map[string]bool, len(active))
|
||||
@@ -322,7 +360,7 @@ func (c *controller) refresh() {
|
||||
c.logout("登录已失效,请输入密码重新连接")
|
||||
return
|
||||
}
|
||||
c.status.Set(friendlyError(err))
|
||||
c.errorMsg.Set(friendlyError(err))
|
||||
return
|
||||
}
|
||||
c.sessions.Set(page.Data)
|
||||
@@ -337,31 +375,143 @@ func (c *controller) refresh() {
|
||||
}()
|
||||
}
|
||||
|
||||
// logout drops the session but keeps the address so the user only types
|
||||
// the password again.
|
||||
// logout drops the live session but keeps the saved servers.
|
||||
func (c *controller) logout(reason string) {
|
||||
if c.cancelSSE != nil {
|
||||
c.cancelSSE()
|
||||
c.cancelSSE = nil
|
||||
}
|
||||
if c.client != nil {
|
||||
server := c.client.BaseURL()
|
||||
go func() { _ = c.st.ClearToken(server) }()
|
||||
}
|
||||
if c.chat != nil && c.chat.nav != nil && c.chat.nav.Depth() > 1 {
|
||||
c.chat.nav.Pop()
|
||||
var conn storage.Connection
|
||||
if id := c.activeID.Peek(); id != "" {
|
||||
for _, saved := range c.connections.Peek() {
|
||||
if saved.ID == id {
|
||||
conn = saved
|
||||
}
|
||||
}
|
||||
}
|
||||
c.client = nil
|
||||
c.connected.Set(false)
|
||||
c.activeID.Set("")
|
||||
c.sessions.Set(nil)
|
||||
c.active.Set(map[string]bool{})
|
||||
c.perms.Set(nil)
|
||||
c.server.Set("")
|
||||
c.status.Set(reason)
|
||||
c.errorMsg.Set(reason)
|
||||
if conn.ID != "" && reason != "" {
|
||||
go func() { _ = c.st.ClearToken(conn) }()
|
||||
}
|
||||
}
|
||||
|
||||
func (c *controller) disconnect() {
|
||||
c.logout("已断开")
|
||||
if c.chat != nil && c.chat.nav != nil && c.chat.nav.Depth() > 1 {
|
||||
c.chat.nav.Pop()
|
||||
}
|
||||
c.logout("")
|
||||
}
|
||||
|
||||
// --- form ---------------------------------------------------------------
|
||||
|
||||
func (c *controller) openAddForm() {
|
||||
c.formEditID = ""
|
||||
c.url.Set("")
|
||||
c.formLabel.Set("")
|
||||
c.formUseProxy.Set(false)
|
||||
c.formProxy.Set("")
|
||||
c.formInsecure.Set(false)
|
||||
c.errorMsg.Set("")
|
||||
c.formOpen.Set(true)
|
||||
}
|
||||
|
||||
func (c *controller) openEditForm(conn storage.Connection) {
|
||||
c.formEditID = conn.ID
|
||||
c.url.Set(conn.URL)
|
||||
c.formLabel.Set(conn.Label)
|
||||
c.formUseProxy.Set(conn.Proxy != "")
|
||||
c.formProxy.Set(conn.Proxy)
|
||||
c.formInsecure.Set(conn.Insecure)
|
||||
c.errorMsg.Set("")
|
||||
c.formOpen.Set(true)
|
||||
}
|
||||
|
||||
func (c *controller) closeForm() {
|
||||
c.formOpen.Set(false)
|
||||
c.errorMsg.Set("")
|
||||
}
|
||||
|
||||
func (c *controller) submitForm() {
|
||||
raw := strings.TrimSpace(c.url.Peek())
|
||||
if raw == "" {
|
||||
c.errorMsg.Set("请输入服务器地址")
|
||||
return
|
||||
}
|
||||
normalized, err := ocapi.NormalizeBaseURL(raw)
|
||||
if err != nil {
|
||||
c.errorMsg.Set(friendlyError(err))
|
||||
return
|
||||
}
|
||||
conn := storage.Connection{ID: c.formEditID, URL: normalized, Label: strings.TrimSpace(c.formLabel.Peek())}
|
||||
if c.formUseProxy.Peek() {
|
||||
conn.Proxy = strings.TrimSpace(c.formProxy.Peek())
|
||||
}
|
||||
conn.Insecure = c.formInsecure.Peek()
|
||||
if conn.ID != "" {
|
||||
for _, saved := range c.connections.Peek() {
|
||||
if saved.ID == conn.ID {
|
||||
conn.ServerID = saved.ServerID
|
||||
conn.Passwordless = saved.Passwordless
|
||||
conn.LastUsedAt = saved.LastUsedAt
|
||||
}
|
||||
}
|
||||
}
|
||||
if conn.ID == "" {
|
||||
conn.ID = storage.NewID()
|
||||
}
|
||||
c.saveConnection(conn)
|
||||
c.formOpen.Set(false)
|
||||
|
||||
if !c.connected.Peek() {
|
||||
c.connectTo(conn, "", true)
|
||||
return
|
||||
}
|
||||
c.status.Set("已保存")
|
||||
}
|
||||
|
||||
// --- password -----------------------------------------------------------
|
||||
|
||||
func (c *controller) askPassword(conn storage.Connection) {
|
||||
c.passwordFor = conn
|
||||
c.passwordText.Set("")
|
||||
c.passwordBusy.Set(false)
|
||||
c.passwordOpen.Set(true)
|
||||
}
|
||||
|
||||
func (c *controller) submitPassword() {
|
||||
if c.passwordBusy.Peek() {
|
||||
return
|
||||
}
|
||||
pw := c.passwordText.Peek()
|
||||
if strings.TrimSpace(pw) == "" {
|
||||
return
|
||||
}
|
||||
conn := c.passwordFor
|
||||
c.passwordBusy.Set(true)
|
||||
c.passwordOpen.Set(false)
|
||||
c.connectToPassword(conn, pw)
|
||||
}
|
||||
|
||||
func (c *controller) connectToPassword(conn storage.Connection, password string) {
|
||||
if c.connecting.Peek() != "" {
|
||||
return
|
||||
}
|
||||
c.connecting.Set(conn.ID)
|
||||
c.errorMsg.Set("")
|
||||
go func() { c.establish(conn, password, true) }()
|
||||
}
|
||||
|
||||
func (c *controller) cancelPassword() {
|
||||
c.passwordOpen.Set(false)
|
||||
c.passwordText.Set("")
|
||||
c.passwordBusy.Set(false)
|
||||
}
|
||||
|
||||
var errUnauthorized = errors.New("这个服务器需要密码")
|
||||
@@ -399,6 +549,17 @@ func friendlyError(err error) string {
|
||||
return msg
|
||||
}
|
||||
|
||||
func hostOf(raw string) string {
|
||||
s := strings.TrimSpace(raw)
|
||||
if i := strings.Index(s, "://"); i >= 0 {
|
||||
s = s[i+3:]
|
||||
}
|
||||
if i := strings.IndexByte(s, '/'); i >= 0 {
|
||||
s = s[:i]
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func shortPath(p string) string {
|
||||
p = strings.TrimRight(p, "/")
|
||||
if p == "" {
|
||||
|
||||
Reference in new issue
Block a user