login1

package
v0.0.0-...-77ac5d6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 28, 2023 License: GPL-3.0 Imports: 7 Imported by: 19

Documentation

Overview

SPDX-FileCopyrightText: 2018 - 2023 UnionTech Software Technology Co., Ltd.

SPDX-License-Identifier: GPL-3.0-or-later

SPDX-FileCopyrightText: 2018 - 2023 UnionTech Software Technology Co., Ltd.

SPDX-License-Identifier: GPL-3.0-or-later

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type InhibitorInfo 

type InhibitorInfo struct {
	What string
	Who  string
	Why  string
	Mode string
	UID  uint32
	PID  uint32
}

type Manager 

type Manager interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewManager 

func NewManager(conn *dbus.Conn) Manager

type MockInterfaceManager 

type MockInterfaceManager struct {
	mock.Mock
}

func (*MockInterfaceManager) ActivateSession 

func (v *MockInterfaceManager) ActivateSession(flags dbus.Flags, sessionId string) error

func (*MockInterfaceManager) ActivateSessionOnSeat 

func (v *MockInterfaceManager) ActivateSessionOnSeat(flags dbus.Flags, sessionId string, seatId string) error

func (*MockInterfaceManager) AttachDevice 

func (v *MockInterfaceManager) AttachDevice(flags dbus.Flags, seatId string, sysfs string, interactive bool) error

func (*MockInterfaceManager) BlockInhibited 

func (v *MockInterfaceManager) BlockInhibited() proxy.PropString

func (*MockInterfaceManager) CanHibernate 

func (v *MockInterfaceManager) CanHibernate(flags dbus.Flags) (string, error)

func (*MockInterfaceManager) CanHybridSleep 

func (v *MockInterfaceManager) CanHybridSleep(flags dbus.Flags) (string, error)

func (*MockInterfaceManager) CanPowerOff 

func (v *MockInterfaceManager) CanPowerOff(flags dbus.Flags) (string, error)

func (*MockInterfaceManager) CanReboot 

func (v *MockInterfaceManager) CanReboot(flags dbus.Flags) (string, error)

func (*MockInterfaceManager) CanRebootToFirmwareSetup 

func (v *MockInterfaceManager) CanRebootToFirmwareSetup(flags dbus.Flags) (string, error)

func (*MockInterfaceManager) CanSuspend 

func (v *MockInterfaceManager) CanSuspend(flags dbus.Flags) (string, error)

func (*MockInterfaceManager) CancelScheduledShutdown 

func (v *MockInterfaceManager) CancelScheduledShutdown(flags dbus.Flags) (bool, error)

func (*MockInterfaceManager) ConnectPrepareForShutdown 

func (v *MockInterfaceManager) ConnectPrepareForShutdown(cb func(start bool)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectPrepareForSleep 

func (v *MockInterfaceManager) ConnectPrepareForSleep(cb func(start bool)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectSeatNew 

func (v *MockInterfaceManager) ConnectSeatNew(cb func(seatId string, seatPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectSeatRemoved 

func (v *MockInterfaceManager) ConnectSeatRemoved(cb func(seatId string, seatPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectSessionNew 

func (v *MockInterfaceManager) ConnectSessionNew(cb func(sessionId string, sessionPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectSessionRemoved 

func (v *MockInterfaceManager) ConnectSessionRemoved(cb func(sessionId string, sessionPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectUserNew 

func (v *MockInterfaceManager) ConnectUserNew(cb func(uid uint32, userPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) ConnectUserRemoved 

func (v *MockInterfaceManager) ConnectUserRemoved(cb func(uid uint32, userPath dbus.ObjectPath)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceManager) CreateSession 

func (v *MockInterfaceManager) CreateSession(flags dbus.Flags, uid uint32, pid uint32, service string, type0 string, class string, desktop string, seatId string, vtnr uint32, tty string, display string, remote bool, remoteUser string, remoteHost string, properties [][]interface{}) (string, dbus.ObjectPath, string, dbus.UnixFD, uint32, string, uint32, bool, error)

func (*MockInterfaceManager) DelayInhibited 

func (v *MockInterfaceManager) DelayInhibited() proxy.PropString

func (*MockInterfaceManager) Docked 

func (v *MockInterfaceManager) Docked() proxy.PropBool

func (*MockInterfaceManager) EnableWallMessages 

func (v *MockInterfaceManager) EnableWallMessages() proxy.PropBool

func (*MockInterfaceManager) FlushDevices 

func (v *MockInterfaceManager) FlushDevices(flags dbus.Flags, interactive bool) error

func (*MockInterfaceManager) GetSeat 

func (v *MockInterfaceManager) GetSeat(flags dbus.Flags, seatId string) (dbus.ObjectPath, error)

func (*MockInterfaceManager) GetSession 

func (v *MockInterfaceManager) GetSession(flags dbus.Flags, sessionId string) (dbus.ObjectPath, error)

func (*MockInterfaceManager) GetSessionByPID 

func (v *MockInterfaceManager) GetSessionByPID(flags dbus.Flags, pid uint32) (dbus.ObjectPath, error)

func (*MockInterfaceManager) GetUser 

func (v *MockInterfaceManager) GetUser(flags dbus.Flags, uid uint32) (dbus.ObjectPath, error)

func (*MockInterfaceManager) GetUserByPID 

func (v *MockInterfaceManager) GetUserByPID(flags dbus.Flags, pid uint32) (dbus.ObjectPath, error)

func (*MockInterfaceManager) GoActivateSession 

func (v *MockInterfaceManager) GoActivateSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call

func (*MockInterfaceManager) GoActivateSessionOnSeat 

func (v *MockInterfaceManager) GoActivateSessionOnSeat(flags dbus.Flags, ch chan *dbus.Call, sessionId string, seatId string) *dbus.Call

func (*MockInterfaceManager) GoAttachDevice 

func (v *MockInterfaceManager) GoAttachDevice(flags dbus.Flags, ch chan *dbus.Call, seatId string, sysfs string, interactive bool) *dbus.Call

func (*MockInterfaceManager) GoCanHibernate 

func (v *MockInterfaceManager) GoCanHibernate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoCanHybridSleep 

func (v *MockInterfaceManager) GoCanHybridSleep(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoCanPowerOff 

func (v *MockInterfaceManager) GoCanPowerOff(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoCanReboot 

func (v *MockInterfaceManager) GoCanReboot(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoCanRebootToFirmwareSetup 

func (v *MockInterfaceManager) GoCanRebootToFirmwareSetup(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoCanSuspend 

func (v *MockInterfaceManager) GoCanSuspend(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoCancelScheduledShutdown 

func (v *MockInterfaceManager) GoCancelScheduledShutdown(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoCreateSession 

func (v *MockInterfaceManager) GoCreateSession(flags dbus.Flags, ch chan *dbus.Call, uid uint32, pid uint32, service string, type0 string, class string, desktop string, seatId string, vtnr uint32, tty string, display string, remote bool, remoteUser string, remoteHost string, properties [][]interface{}) *dbus.Call

func (*MockInterfaceManager) GoFlushDevices 

func (v *MockInterfaceManager) GoFlushDevices(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call

func (*MockInterfaceManager) GoGetSeat 

func (v *MockInterfaceManager) GoGetSeat(flags dbus.Flags, ch chan *dbus.Call, seatId string) *dbus.Call

func (*MockInterfaceManager) GoGetSession 

func (v *MockInterfaceManager) GoGetSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call

func (*MockInterfaceManager) GoGetSessionByPID 

func (v *MockInterfaceManager) GoGetSessionByPID(flags dbus.Flags, ch chan *dbus.Call, pid uint32) *dbus.Call

func (*MockInterfaceManager) GoGetUser 

func (v *MockInterfaceManager) GoGetUser(flags dbus.Flags, ch chan *dbus.Call, uid uint32) *dbus.Call

func (*MockInterfaceManager) GoGetUserByPID 

func (v *MockInterfaceManager) GoGetUserByPID(flags dbus.Flags, ch chan *dbus.Call, pid uint32) *dbus.Call

func (*MockInterfaceManager) GoHibernate 

func (v *MockInterfaceManager) GoHibernate(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call

func (*MockInterfaceManager) GoHybridSleep 

func (v *MockInterfaceManager) GoHybridSleep(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call

func (*MockInterfaceManager) GoInhibit 

func (v *MockInterfaceManager) GoInhibit(flags dbus.Flags, ch chan *dbus.Call, what string, who string, why string, mode string) *dbus.Call

func (*MockInterfaceManager) GoKillSession 

func (v *MockInterfaceManager) GoKillSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string, who string, signo int32) *dbus.Call

func (*MockInterfaceManager) GoKillUser 

func (v *MockInterfaceManager) GoKillUser(flags dbus.Flags, ch chan *dbus.Call, uid uint32, signo int32) *dbus.Call

func (*MockInterfaceManager) GoListInhibitors 

func (v *MockInterfaceManager) GoListInhibitors(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoListSeats 

func (v *MockInterfaceManager) GoListSeats(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoListSessions 

func (v *MockInterfaceManager) GoListSessions(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoListUsers 

func (v *MockInterfaceManager) GoListUsers(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoLockSession 

func (v *MockInterfaceManager) GoLockSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call

func (*MockInterfaceManager) GoLockSessions 

func (v *MockInterfaceManager) GoLockSessions(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) GoPowerOff 

func (v *MockInterfaceManager) GoPowerOff(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call

func (*MockInterfaceManager) GoReboot 

func (v *MockInterfaceManager) GoReboot(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call

func (*MockInterfaceManager) GoReleaseSession 

func (v *MockInterfaceManager) GoReleaseSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call

func (*MockInterfaceManager) GoScheduleShutdown 

func (v *MockInterfaceManager) GoScheduleShutdown(flags dbus.Flags, ch chan *dbus.Call, type0 string, usec uint64) *dbus.Call

func (*MockInterfaceManager) GoSetRebootToFirmwareSetup 

func (v *MockInterfaceManager) GoSetRebootToFirmwareSetup(flags dbus.Flags, ch chan *dbus.Call, enable bool) *dbus.Call

func (*MockInterfaceManager) GoSetUserLinger 

func (v *MockInterfaceManager) GoSetUserLinger(flags dbus.Flags, ch chan *dbus.Call, uid uint32, linger bool, interactive bool) *dbus.Call

func (*MockInterfaceManager) GoSetWallMessage 

func (v *MockInterfaceManager) GoSetWallMessage(flags dbus.Flags, ch chan *dbus.Call, wallMessage string, enable bool) *dbus.Call

func (*MockInterfaceManager) GoSuspend 

func (v *MockInterfaceManager) GoSuspend(flags dbus.Flags, ch chan *dbus.Call, interactive bool) *dbus.Call

func (*MockInterfaceManager) GoTerminateSeat 

func (v *MockInterfaceManager) GoTerminateSeat(flags dbus.Flags, ch chan *dbus.Call, seatId string) *dbus.Call

func (*MockInterfaceManager) GoTerminateSession 

func (v *MockInterfaceManager) GoTerminateSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call

func (*MockInterfaceManager) GoTerminateUser 

func (v *MockInterfaceManager) GoTerminateUser(flags dbus.Flags, ch chan *dbus.Call, uid uint32) *dbus.Call

func (*MockInterfaceManager) GoUnlockSession 

func (v *MockInterfaceManager) GoUnlockSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call

func (*MockInterfaceManager) GoUnlockSessions 

func (v *MockInterfaceManager) GoUnlockSessions(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceManager) HandleHibernateKey 

func (v *MockInterfaceManager) HandleHibernateKey() proxy.PropString

func (*MockInterfaceManager) HandleLidSwitch 

func (v *MockInterfaceManager) HandleLidSwitch() proxy.PropString

func (*MockInterfaceManager) HandleLidSwitchDocked 

func (v *MockInterfaceManager) HandleLidSwitchDocked() proxy.PropString

func (*MockInterfaceManager) HandlePowerKey 

func (v *MockInterfaceManager) HandlePowerKey() proxy.PropString

func (*MockInterfaceManager) HandleSuspendKey 

func (v *MockInterfaceManager) HandleSuspendKey() proxy.PropString

func (*MockInterfaceManager) Hibernate 

func (v *MockInterfaceManager) Hibernate(flags dbus.Flags, interactive bool) error

func (*MockInterfaceManager) HoldoffTimeoutUSec 

func (v *MockInterfaceManager) HoldoffTimeoutUSec() proxy.PropUint64

func (*MockInterfaceManager) HybridSleep 

func (v *MockInterfaceManager) HybridSleep(flags dbus.Flags, interactive bool) error

func (*MockInterfaceManager) IdleAction 

func (v *MockInterfaceManager) IdleAction() proxy.PropString

func (*MockInterfaceManager) IdleActionUSec 

func (v *MockInterfaceManager) IdleActionUSec() proxy.PropUint64

func (*MockInterfaceManager) IdleHint 

func (v *MockInterfaceManager) IdleHint() proxy.PropBool

func (*MockInterfaceManager) IdleSinceHint 

func (v *MockInterfaceManager) IdleSinceHint() proxy.PropUint64

func (*MockInterfaceManager) IdleSinceHintMonotonic 

func (v *MockInterfaceManager) IdleSinceHintMonotonic() proxy.PropUint64

func (*MockInterfaceManager) Inhibit 

func (v *MockInterfaceManager) Inhibit(flags dbus.Flags, what string, who string, why string, mode string) (dbus.UnixFD, error)

func (*MockInterfaceManager) InhibitDelayMaxUSec 

func (v *MockInterfaceManager) InhibitDelayMaxUSec() proxy.PropUint64

func (*MockInterfaceManager) InhibitorsMax 

func (v *MockInterfaceManager) InhibitorsMax() proxy.PropUint64

func (*MockInterfaceManager) KillExcludeUsers 

func (v *MockInterfaceManager) KillExcludeUsers() proxy.PropStringArray

func (*MockInterfaceManager) KillOnlyUsers 

func (v *MockInterfaceManager) KillOnlyUsers() proxy.PropStringArray

func (*MockInterfaceManager) KillSession 

func (v *MockInterfaceManager) KillSession(flags dbus.Flags, sessionId string, who string, signo int32) error

func (*MockInterfaceManager) KillUser 

func (v *MockInterfaceManager) KillUser(flags dbus.Flags, uid uint32, signo int32) error

func (*MockInterfaceManager) KillUserProcesses 

func (v *MockInterfaceManager) KillUserProcesses() proxy.PropBool

func (*MockInterfaceManager) ListInhibitors 

func (v *MockInterfaceManager) ListInhibitors(flags dbus.Flags) ([]InhibitorInfo, error)

func (*MockInterfaceManager) ListSeats 

func (v *MockInterfaceManager) ListSeats(flags dbus.Flags) ([]SeatInfo, error)

func (*MockInterfaceManager) ListSessions 

func (v *MockInterfaceManager) ListSessions(flags dbus.Flags) ([]SessionDetail, error)

func (*MockInterfaceManager) ListUsers 

func (v *MockInterfaceManager) ListUsers(flags dbus.Flags) ([]UserDetail, error)

func (*MockInterfaceManager) LockSession 

func (v *MockInterfaceManager) LockSession(flags dbus.Flags, sessionId string) error

func (*MockInterfaceManager) LockSessions 

func (v *MockInterfaceManager) LockSessions(flags dbus.Flags) error

func (*MockInterfaceManager) NAutoVTs 

func (v *MockInterfaceManager) NAutoVTs() proxy.PropUint32

func (*MockInterfaceManager) NCurrentInhibitors 

func (v *MockInterfaceManager) NCurrentInhibitors() proxy.PropUint64

func (*MockInterfaceManager) NCurrentSessions 

func (v *MockInterfaceManager) NCurrentSessions() proxy.PropUint64

func (*MockInterfaceManager) PowerOff 

func (v *MockInterfaceManager) PowerOff(flags dbus.Flags, interactive bool) error

func (*MockInterfaceManager) PreparingForShutdown 

func (v *MockInterfaceManager) PreparingForShutdown() proxy.PropBool

func (*MockInterfaceManager) PreparingForSleep 

func (v *MockInterfaceManager) PreparingForSleep() proxy.PropBool

func (*MockInterfaceManager) Reboot 

func (v *MockInterfaceManager) Reboot(flags dbus.Flags, interactive bool) error

func (*MockInterfaceManager) RebootToFirmwareSetup 

func (v *MockInterfaceManager) RebootToFirmwareSetup() proxy.PropBool

func (*MockInterfaceManager) ReleaseSession 

func (v *MockInterfaceManager) ReleaseSession(flags dbus.Flags, sessionId string) error

func (*MockInterfaceManager) RemoveIPC 

func (v *MockInterfaceManager) RemoveIPC() proxy.PropBool

func (*MockInterfaceManager) RuntimeDirectorySize 

func (v *MockInterfaceManager) RuntimeDirectorySize() proxy.PropUint64

func (*MockInterfaceManager) ScheduleShutdown 

func (v *MockInterfaceManager) ScheduleShutdown(flags dbus.Flags, type0 string, usec uint64) error

func (*MockInterfaceManager) ScheduledShutdown 

func (v *MockInterfaceManager) ScheduledShutdown() PropManagerScheduledShutdown

func (*MockInterfaceManager) SessionsMax 

func (v *MockInterfaceManager) SessionsMax() proxy.PropUint64

func (*MockInterfaceManager) SetRebootToFirmwareSetup 

func (v *MockInterfaceManager) SetRebootToFirmwareSetup(flags dbus.Flags, enable bool) error

func (*MockInterfaceManager) SetUserLinger 

func (v *MockInterfaceManager) SetUserLinger(flags dbus.Flags, uid uint32, linger bool, interactive bool) error

func (*MockInterfaceManager) SetWallMessage 

func (v *MockInterfaceManager) SetWallMessage(flags dbus.Flags, wallMessage string, enable bool) error

func (*MockInterfaceManager) Suspend 

func (v *MockInterfaceManager) Suspend(flags dbus.Flags, interactive bool) error

func (*MockInterfaceManager) TerminateSeat 

func (v *MockInterfaceManager) TerminateSeat(flags dbus.Flags, seatId string) error

func (*MockInterfaceManager) TerminateSession 

func (v *MockInterfaceManager) TerminateSession(flags dbus.Flags, sessionId string) error

func (*MockInterfaceManager) TerminateUser 

func (v *MockInterfaceManager) TerminateUser(flags dbus.Flags, uid uint32) error

func (*MockInterfaceManager) UnlockSession 

func (v *MockInterfaceManager) UnlockSession(flags dbus.Flags, sessionId string) error

func (*MockInterfaceManager) UnlockSessions 

func (v *MockInterfaceManager) UnlockSessions(flags dbus.Flags) error

func (*MockInterfaceManager) UserTasksMax 

func (v *MockInterfaceManager) UserTasksMax() proxy.PropUint64

func (*MockInterfaceManager) WallMessage 

func (v *MockInterfaceManager) WallMessage() proxy.PropString

type MockInterfaceSeat 

type MockInterfaceSeat struct {
	mock.Mock
}

func (*MockInterfaceSeat) ActivateSession 

func (v *MockInterfaceSeat) ActivateSession(flags dbus.Flags, sessionId string) error

func (*MockInterfaceSeat) ActiveSession 

func (v *MockInterfaceSeat) ActiveSession() PropSessionInfo

func (*MockInterfaceSeat) CanGraphical 

func (v *MockInterfaceSeat) CanGraphical() proxy.PropBool

func (*MockInterfaceSeat) CanMultiSession 

func (v *MockInterfaceSeat) CanMultiSession() proxy.PropBool

func (*MockInterfaceSeat) CanTTY 

func (v *MockInterfaceSeat) CanTTY() proxy.PropBool

func (*MockInterfaceSeat) GoActivateSession 

func (v *MockInterfaceSeat) GoActivateSession(flags dbus.Flags, ch chan *dbus.Call, sessionId string) *dbus.Call

func (*MockInterfaceSeat) GoSwitchTo 

func (v *MockInterfaceSeat) GoSwitchTo(flags dbus.Flags, ch chan *dbus.Call, vtnr uint32) *dbus.Call

func (*MockInterfaceSeat) GoSwitchToNext 

func (v *MockInterfaceSeat) GoSwitchToNext(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceSeat) GoSwitchToPrevious 

func (v *MockInterfaceSeat) GoSwitchToPrevious(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceSeat) GoTerminate 

func (v *MockInterfaceSeat) GoTerminate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceSeat) Id 

func (v *MockInterfaceSeat) Id() proxy.PropString

func (*MockInterfaceSeat) IdleHint 

func (v *MockInterfaceSeat) IdleHint() proxy.PropBool

func (*MockInterfaceSeat) IdleSinceHint 

func (v *MockInterfaceSeat) IdleSinceHint() proxy.PropUint64

func (*MockInterfaceSeat) IdleSinceHintMonotonic 

func (v *MockInterfaceSeat) IdleSinceHintMonotonic() proxy.PropUint64

func (*MockInterfaceSeat) Sessions 

func (v *MockInterfaceSeat) Sessions() PropSessionInfoSlice

func (*MockInterfaceSeat) SwitchTo 

func (v *MockInterfaceSeat) SwitchTo(flags dbus.Flags, vtnr uint32) error

func (*MockInterfaceSeat) SwitchToNext 

func (v *MockInterfaceSeat) SwitchToNext(flags dbus.Flags) error

func (*MockInterfaceSeat) SwitchToPrevious 

func (v *MockInterfaceSeat) SwitchToPrevious(flags dbus.Flags) error

func (*MockInterfaceSeat) Terminate 

func (v *MockInterfaceSeat) Terminate(flags dbus.Flags) error

type MockInterfaceSession 

type MockInterfaceSession struct {
	mock.Mock
}

func (*MockInterfaceSession) Activate 

func (v *MockInterfaceSession) Activate(flags dbus.Flags) error

func (*MockInterfaceSession) Active 

func (v *MockInterfaceSession) Active() proxy.PropBool

func (*MockInterfaceSession) Audit 

func (v *MockInterfaceSession) Audit() proxy.PropUint32

func (*MockInterfaceSession) Class 

func (v *MockInterfaceSession) Class() proxy.PropString

func (*MockInterfaceSession) ConnectLock 

func (v *MockInterfaceSession) ConnectLock(cb func()) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceSession) ConnectPauseDevice 

func (v *MockInterfaceSession) ConnectPauseDevice(cb func(major uint32, minor uint32, type0 string)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceSession) ConnectResumeDevice 

func (v *MockInterfaceSession) ConnectResumeDevice(cb func(major uint32, minor uint32, fd dbus.UnixFD)) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceSession) ConnectUnlock 

func (v *MockInterfaceSession) ConnectUnlock(cb func()) (dbusutil.SignalHandlerId, error)

func (*MockInterfaceSession) Desktop 

func (v *MockInterfaceSession) Desktop() proxy.PropString

func (*MockInterfaceSession) Display 

func (v *MockInterfaceSession) Display() proxy.PropString

func (*MockInterfaceSession) GoActivate 

func (v *MockInterfaceSession) GoActivate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceSession) GoKill 

func (v *MockInterfaceSession) GoKill(flags dbus.Flags, ch chan *dbus.Call, who string, signo int32) *dbus.Call

func (*MockInterfaceSession) GoLock 

func (v *MockInterfaceSession) GoLock(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceSession) GoPauseDeviceComplete 

func (v *MockInterfaceSession) GoPauseDeviceComplete(flags dbus.Flags, ch chan *dbus.Call, major uint32, minor uint32) *dbus.Call

func (*MockInterfaceSession) GoReleaseControl 

func (v *MockInterfaceSession) GoReleaseControl(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceSession) GoReleaseDevice 

func (v *MockInterfaceSession) GoReleaseDevice(flags dbus.Flags, ch chan *dbus.Call, major uint32, minor uint32) *dbus.Call

func (*MockInterfaceSession) GoSetIdleHint 

func (v *MockInterfaceSession) GoSetIdleHint(flags dbus.Flags, ch chan *dbus.Call, idle bool) *dbus.Call

func (*MockInterfaceSession) GoSetLockedHint 

func (v *MockInterfaceSession) GoSetLockedHint(flags dbus.Flags, ch chan *dbus.Call, locked bool) *dbus.Call

func (*MockInterfaceSession) GoTakeControl 

func (v *MockInterfaceSession) GoTakeControl(flags dbus.Flags, ch chan *dbus.Call, force bool) *dbus.Call

func (*MockInterfaceSession) GoTakeDevice 

func (v *MockInterfaceSession) GoTakeDevice(flags dbus.Flags, ch chan *dbus.Call, major uint32, minor uint32) *dbus.Call

func (*MockInterfaceSession) GoTerminate 

func (v *MockInterfaceSession) GoTerminate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceSession) GoUnlock 

func (v *MockInterfaceSession) GoUnlock(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceSession) Id 

func (v *MockInterfaceSession) Id() proxy.PropString

func (*MockInterfaceSession) IdleHint 

func (v *MockInterfaceSession) IdleHint() proxy.PropBool

func (*MockInterfaceSession) IdleSinceHint 

func (v *MockInterfaceSession) IdleSinceHint() proxy.PropUint64

func (*MockInterfaceSession) IdleSinceHintMonotonic 

func (v *MockInterfaceSession) IdleSinceHintMonotonic() proxy.PropUint64

func (*MockInterfaceSession) Kill 

func (v *MockInterfaceSession) Kill(flags dbus.Flags, who string, signo int32) error

func (*MockInterfaceSession) Leader 

func (v *MockInterfaceSession) Leader() proxy.PropUint32

func (*MockInterfaceSession) Lock 

func (v *MockInterfaceSession) Lock(flags dbus.Flags) error

func (*MockInterfaceSession) LockedHint 

func (v *MockInterfaceSession) LockedHint() proxy.PropBool

func (*MockInterfaceSession) Name 

func (v *MockInterfaceSession) Name() proxy.PropString

func (*MockInterfaceSession) PauseDeviceComplete 

func (v *MockInterfaceSession) PauseDeviceComplete(flags dbus.Flags, major uint32, minor uint32) error

func (*MockInterfaceSession) ReleaseControl 

func (v *MockInterfaceSession) ReleaseControl(flags dbus.Flags) error

func (*MockInterfaceSession) ReleaseDevice 

func (v *MockInterfaceSession) ReleaseDevice(flags dbus.Flags, major uint32, minor uint32) error

func (*MockInterfaceSession) Remote 

func (v *MockInterfaceSession) Remote() proxy.PropBool

func (*MockInterfaceSession) RemoteHost 

func (v *MockInterfaceSession) RemoteHost() proxy.PropString

func (*MockInterfaceSession) RemoteUser 

func (v *MockInterfaceSession) RemoteUser() proxy.PropString

func (*MockInterfaceSession) Scope 

func (v *MockInterfaceSession) Scope() proxy.PropString

func (*MockInterfaceSession) Seat 

func (v *MockInterfaceSession) Seat() PropSessionSeat

func (*MockInterfaceSession) Service 

func (v *MockInterfaceSession) Service() proxy.PropString

func (*MockInterfaceSession) SetIdleHint 

func (v *MockInterfaceSession) SetIdleHint(flags dbus.Flags, idle bool) error

func (*MockInterfaceSession) SetLockedHint 

func (v *MockInterfaceSession) SetLockedHint(flags dbus.Flags, locked bool) error

func (*MockInterfaceSession) State 

func (v *MockInterfaceSession) State() proxy.PropString

func (*MockInterfaceSession) TTY 

func (v *MockInterfaceSession) TTY() proxy.PropString

func (*MockInterfaceSession) TakeControl 

func (v *MockInterfaceSession) TakeControl(flags dbus.Flags, force bool) error

func (*MockInterfaceSession) TakeDevice 

func (v *MockInterfaceSession) TakeDevice(flags dbus.Flags, major uint32, minor uint32) (dbus.UnixFD, bool, error)

func (*MockInterfaceSession) Terminate 

func (v *MockInterfaceSession) Terminate(flags dbus.Flags) error

func (*MockInterfaceSession) Timestamp 

func (v *MockInterfaceSession) Timestamp() proxy.PropUint64

func (*MockInterfaceSession) TimestampMonotonic 

func (v *MockInterfaceSession) TimestampMonotonic() proxy.PropUint64

func (*MockInterfaceSession) Type 

func (v *MockInterfaceSession) Type() proxy.PropString

func (*MockInterfaceSession) Unlock 

func (v *MockInterfaceSession) Unlock(flags dbus.Flags) error

func (*MockInterfaceSession) User 

func (v *MockInterfaceSession) User() PropSessionUser

func (*MockInterfaceSession) VTNr 

func (v *MockInterfaceSession) VTNr() proxy.PropUint32

type MockInterfaceUser 

type MockInterfaceUser struct {
	mock.Mock
}

func (*MockInterfaceUser) Display 

func (v *MockInterfaceUser) Display() PropSessionInfo

func (*MockInterfaceUser) GID 

func (v *MockInterfaceUser) GID() proxy.PropUint32

func (*MockInterfaceUser) GoKill 

func (v *MockInterfaceUser) GoKill(flags dbus.Flags, ch chan *dbus.Call, signo int32) *dbus.Call

func (*MockInterfaceUser) GoTerminate 

func (v *MockInterfaceUser) GoTerminate(flags dbus.Flags, ch chan *dbus.Call) *dbus.Call

func (*MockInterfaceUser) IdleHint 

func (v *MockInterfaceUser) IdleHint() proxy.PropBool

func (*MockInterfaceUser) IdleSinceHint 

func (v *MockInterfaceUser) IdleSinceHint() proxy.PropUint64

func (*MockInterfaceUser) IdleSinceHintMonotonic 

func (v *MockInterfaceUser) IdleSinceHintMonotonic() proxy.PropUint64

func (*MockInterfaceUser) Kill 

func (v *MockInterfaceUser) Kill(flags dbus.Flags, signo int32) error

func (*MockInterfaceUser) Linger 

func (v *MockInterfaceUser) Linger() proxy.PropBool

func (*MockInterfaceUser) Name 

func (v *MockInterfaceUser) Name() proxy.PropString

func (*MockInterfaceUser) RuntimePath 

func (v *MockInterfaceUser) RuntimePath() proxy.PropString

func (*MockInterfaceUser) Service 

func (v *MockInterfaceUser) Service() proxy.PropString

func (*MockInterfaceUser) Sessions 

func (v *MockInterfaceUser) Sessions() PropSessionInfoSlice

func (*MockInterfaceUser) Slice 

func (v *MockInterfaceUser) Slice() proxy.PropString

func (*MockInterfaceUser) State 

func (v *MockInterfaceUser) State() proxy.PropString

func (*MockInterfaceUser) Terminate 

func (v *MockInterfaceUser) Terminate(flags dbus.Flags) error

func (*MockInterfaceUser) Timestamp 

func (v *MockInterfaceUser) Timestamp() proxy.PropUint64

func (*MockInterfaceUser) TimestampMonotonic 

func (v *MockInterfaceUser) TimestampMonotonic() proxy.PropUint64

func (*MockInterfaceUser) UID 

func (v *MockInterfaceUser) UID() proxy.PropUint32

type MockManager 

type MockManager struct {
	MockInterfaceManager // interface org.freedesktop.login1.Manager
	proxy.MockObject
}

type MockPropManagerScheduledShutdown 

type MockPropManagerScheduledShutdown struct {
	mock.Mock
}

func (MockPropManagerScheduledShutdown) ConnectChanged 

func (p MockPropManagerScheduledShutdown) ConnectChanged(cb func(hasValue bool, value ScheduledShutdown)) error

func (MockPropManagerScheduledShutdown) Get 

func (p MockPropManagerScheduledShutdown) Get(flags dbus.Flags) (value ScheduledShutdown, err error)

func (MockPropManagerScheduledShutdown) Set 

func (p MockPropManagerScheduledShutdown) Set(flags dbus.Flags, value ScheduledShutdown) error

type MockPropSessionInfo 

type MockPropSessionInfo struct {
	mock.Mock
}

func (MockPropSessionInfo) ConnectChanged 

func (p MockPropSessionInfo) ConnectChanged(cb func(hasValue bool, value SessionInfo)) error

func (MockPropSessionInfo) Get 

func (p MockPropSessionInfo) Get(flags dbus.Flags) (value SessionInfo, err error)

func (MockPropSessionInfo) Set 

func (p MockPropSessionInfo) Set(flags dbus.Flags, value SessionInfo) error

type MockPropSessionInfoSlice 

type MockPropSessionInfoSlice struct {
	mock.Mock
}

func (MockPropSessionInfoSlice) ConnectChanged 

func (p MockPropSessionInfoSlice) ConnectChanged(cb func(hasValue bool, value []SessionInfo)) error

func (MockPropSessionInfoSlice) Get 

func (p MockPropSessionInfoSlice) Get(flags dbus.Flags) (value []SessionInfo, err error)

func (MockPropSessionInfoSlice) Set 

func (p MockPropSessionInfoSlice) Set(flags dbus.Flags, value []SessionInfo) error

type MockPropSessionSeat 

type MockPropSessionSeat struct {
	mock.Mock
}

func (MockPropSessionSeat) ConnectChanged 

func (p MockPropSessionSeat) ConnectChanged(cb func(hasValue bool, value SeatInfo)) error

func (MockPropSessionSeat) Get 

func (p MockPropSessionSeat) Get(flags dbus.Flags) (value SeatInfo, err error)

func (MockPropSessionSeat) Set 

func (p MockPropSessionSeat) Set(flags dbus.Flags, value SeatInfo) error

type MockPropSessionUser 

type MockPropSessionUser struct {
	mock.Mock
}

func (MockPropSessionUser) ConnectChanged 

func (p MockPropSessionUser) ConnectChanged(cb func(hasValue bool, value UserInfo)) error

func (MockPropSessionUser) Get 

func (p MockPropSessionUser) Get(flags dbus.Flags) (value UserInfo, err error)

func (MockPropSessionUser) Set 

func (p MockPropSessionUser) Set(flags dbus.Flags, value UserInfo) error

type MockSeat 

type MockSeat struct {
	MockInterfaceSeat // interface org.freedesktop.login1.Seat
	proxy.MockObject
}

type MockSession 

type MockSession struct {
	MockInterfaceSession // interface org.freedesktop.login1.Session
	proxy.MockObject
}

type MockUser 

type MockUser struct {
	MockInterfaceUser // interface org.freedesktop.login1.User
	proxy.MockObject
}

type PropManagerScheduledShutdown 

type PropManagerScheduledShutdown interface {
	Get(flags dbus.Flags) (value ScheduledShutdown, err error)
	Set(flags dbus.Flags, value ScheduledShutdown) error
	ConnectChanged(cb func(hasValue bool, value ScheduledShutdown)) error
}

type PropSessionInfo 

type PropSessionInfo interface {
	Get(flags dbus.Flags) (value SessionInfo, err error)
	Set(flags dbus.Flags, value SessionInfo) error
	ConnectChanged(cb func(hasValue bool, value SessionInfo)) error
}

type PropSessionInfoSlice 

type PropSessionInfoSlice interface {
	Get(flags dbus.Flags) (value []SessionInfo, err error)
	Set(flags dbus.Flags, value []SessionInfo) error
	ConnectChanged(cb func(hasValue bool, value []SessionInfo)) error
}

type PropSessionSeat 

type PropSessionSeat interface {
	Get(flags dbus.Flags) (value SeatInfo, err error)
	Set(flags dbus.Flags, value SeatInfo) error
	ConnectChanged(cb func(hasValue bool, value SeatInfo)) error
}

type PropSessionUser 

type PropSessionUser interface {
	Get(flags dbus.Flags) (value UserInfo, err error)
	Set(flags dbus.Flags, value UserInfo) error
	ConnectChanged(cb func(hasValue bool, value UserInfo)) error
}

type ScheduledShutdown 

type ScheduledShutdown struct {
	Type string
	USec uint64
}

type Seat 

type Seat interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewSeat 

func NewSeat(conn *dbus.Conn, path dbus.ObjectPath) (Seat, error)

type SeatInfo 

type SeatInfo struct {
	Id   string
	Path dbus.ObjectPath
}

type Session 

type Session interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewSession 

func NewSession(conn *dbus.Conn, path dbus.ObjectPath) (Session, error)

type SessionDetail 

type SessionDetail struct {
	SessionId string
	UID       uint32
	UserName  string
	SeatId    string
	Path      dbus.ObjectPath
}

type SessionInfo 

type SessionInfo struct {
	Id   string
	Path dbus.ObjectPath
}

type User 

type User interface {
	proxy.Object
	// contains filtered or unexported methods
}

func NewUser 

func NewUser(conn *dbus.Conn, path dbus.ObjectPath) (User, error)

type UserDetail 

type UserDetail struct {
	UID  uint32
	Name string
	Path dbus.ObjectPath
}

type UserInfo 

type UserInfo struct {
	UID  uint32
	Path dbus.ObjectPath
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.