cromer
/
tuf-manager
1
0
Fork 0
Code Issues Pull Requests Releases 8 Wiki Activity

code cleanup and openrc script

This commit is contained in:
Chris Cromer 2020-08-05 21:15:32 -04:00
parent fb70d11f2b
commit 6b771cfa98
Signed by: cromer
GPG Key ID: 39CC813FF3C8708A
28 changed files with 2043 additions and 1572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
contrib/meson.build Normal file
View File

@ -0,0 +1 @@
subdir('openrc')

19
contrib/openrc/meson.build Normal file
View File

@ -0,0 +1,19 @@
openrc_config_data = configuration_data()
openrc_config_data.set('SBINDIR', join_paths(get_option('prefix'), get_option('sbindir')))
openrc_config_data.set('LIBEXECDIR', join_paths(get_option('prefix'), get_option('libexecdir'), meson.project_name()))
openrc_config_data_file = configure_file(
input: 'tufmanager.in',
output: 'tufmanager',
configuration: openrc_config_data
)
if openrc
install_data(
openrc_config_data_file,
install_dir: join_paths(get_option('sysconfdir'), 'init.d')
)
permissions = find_program('chmod')
meson.add_install_script('permission.sh', join_paths(get_option('sysconfdir'), 'init.d'))
endif

4
contrib/openrc/permission.sh Executable file
View File

@ -0,0 +1,4 @@
#!/bin/sh -eu
echo "Make OpenRC script executable..."
chmod 755 "${DESTDIR}${1}/tufmanager"

4
contrib/openrc/tufmanager → contrib/openrc/tufmanager.in
View File

@ -11,11 +11,11 @@
# #
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
command=@PKG_PREFIX@/libexec/tuf-manager/tuf-server command=@LIBEXECDIR@/tuf-server
pidfile=/var/run/tufmanager/tufmanager.pid pidfile=/var/run/tufmanager/tufmanager.pid
name="TUF Manager daemon" name="TUF Manager daemon"
depend() depend()
{ {
need dbus need dbus
} }

6
data/dbus/meson.build
View File

@ -1,10 +1,10 @@
dbus_config_data = configuration_data() dbus_config_data = configuration_data()
dbus_config_data.set('LIBEXEC_DIR', join_paths(get_option('prefix'), get_option('libexecdir'), meson.project_name())) dbus_config_data.set('LIBEXECDIR', join_paths(get_option('prefix'), get_option('libexecdir'), meson.project_name()))
dbus_config_data_file = configure_file( dbus_config_data_file = configure_file(
input: 'org.tuf.manager.server.service.in', input: 'org.tuf.manager.server.service.in',
output: 'org.tuf.manager.server.service', output: 'org.tuf.manager.server.service',
configuration: dbus_config_data configuration: dbus_config_data
) )
install_data( install_data(

30
data/dbus/org.tuf.manager.server.conf
View File

@ -2,22 +2,22 @@
<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN" <!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd"> "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
<busconfig> <busconfig>
<!-- Only root can own the service --> <!-- Only root can own the service -->
<policy user="root"> <policy user="root">
<allow own="org.tuf.manager.server"/> <allow own="org.tuf.manager.server"/>
</policy> </policy>
<!-- Allow anyone to invoke methods on the interfaces --> <!-- Allow anyone to invoke methods on the interfaces -->
<policy context="default"> <policy context="default">
<allow send_destination="org.tuf.manager.server" <allow send_destination="org.tuf.manager.server"
send_interface="org.tuf.manager.server"/> send_interface="org.tuf.manager.server"/>
<allow send_destination="org.tuf.manager.server" <allow send_destination="org.tuf.manager.server"
send_interface="org.freedesktop.DBus.Introspectable"/> send_interface="org.freedesktop.DBus.Introspectable"/>
<allow send_destination="org.tuf.manager.server" <allow send_destination="org.tuf.manager.server"
send_interface="org.freedesktop.DBus.Peer"/> send_interface="org.freedesktop.DBus.Peer"/>
<allow send_destination="org.tuf.manager.server" <allow send_destination="org.tuf.manager.server"
send_interface="org.freedesktop.DBus.Properties"/> send_interface="org.freedesktop.DBus.Properties"/>
</policy> </policy>
</busconfig> </busconfig>

2
data/dbus/org.tuf.manager.server.service.in
View File

@ -1,4 +1,4 @@
[D-BUS Service] [D-BUS Service]
Name=org.tuf.manager.server Name=org.tuf.manager.server
Exec=@LIBEXEC_DIR@/tuf-server Exec=@LIBEXECDIR@/tuf-server
User=root User=root

18
data/gschema/meson.build
View File

@ -1,12 +1,12 @@
# server doesn't need gschema, only gui or cli # server doesn't need gschema, only gui or cli
if build_gui or build_cli if build_gui or build_cli
gnome = import('gnome') gnome = import('gnome')
gschemas = files( gschemas = files(
'org.tuf.manager.gschema.xml' 'org.tuf.manager.gschema.xml'
) )
gnome.compile_schemas( gnome.compile_schemas(
build_by_default: true, build_by_default: true,
depend_files: gschemas depend_files: gschemas
) )
install_data('org.tuf.manager.gschema.xml', install_dir: join_paths(get_option('prefix'), get_option('datadir'), 'glib-2.0', 'schemas')) install_data('org.tuf.manager.gschema.xml', install_dir: join_paths(get_option('prefix'), get_option('datadir'), 'glib-2.0', 'schemas'))
endif endif

94
data/gschema/org.tuf.manager.gschema.xml
View File

@ -1,49 +1,49 @@
<schemalist> <schemalist>
<schema id="org.tuf.manager" path="/org/tuf/manager/" gettext-domain="tuf-manager"> <schema id="org.tuf.manager" path="/org/tuf/manager/" gettext-domain="tuf-manager">
<key name="restore" type="b"> <key name="restore" type="b">
<default>false</default> <default>false</default>
<summary>Should TUF Manager restore previous settings when run</summary> <summary>Should TUF Manager restore previous settings when run</summary>
<description> <description>
Should TUF Manager restore previous settings when run Should TUF Manager restore previous settings when run
</description> </description>
</key> </key>
<key name="fan-mode" type="i"> <key name="fan-mode" type="i">
<default>0</default> <default>0</default>
<summary>Fan mode</summary> <summary>Fan mode</summary>
<description> <description>
The saved fan mode The saved fan mode
0 is balanced 0 is balanced
1 is turbo 1 is turbo
2 is silent 2 is silent
</description> </description>
</key> </key>
<key name="keyboard-mode" type="i"> <key name="keyboard-mode" type="i">
<default>0</default> <default>0</default>
<summary>Keyboard mode</summary> <summary>Keyboard mode</summary>
<description> <description>
The saved keyboard mode The saved keyboard mode
0 is static 0 is static
1 is breathing 1 is breathing
2 is color cycle 2 is color cycle
3 is strobing 3 is strobing
</description> </description>
</key> </key>
<key name="keyboard-speed" type="i"> <key name="keyboard-speed" type="i">
<default>0</default> <default>0</default>
<summary>Keyboard speed</summary> <summary>Keyboard speed</summary>
<description> <description>
The saved keyboard speed The saved keyboard speed
0 is slow 0 is slow
1 is medium 1 is medium
2 is fast 2 is fast
</description> </description>
</key> </key>
<key name="keyboard-color" type="s"> <key name="keyboard-color" type="s">
<default>"rgb(255,0,0)"</default> <default>"rgb(255,0,0)"</default>
<summary>Keyboard color</summary> <summary>Keyboard color</summary>
<description> <description>
The saved keyboard color in rgb format The saved keyboard color in rgb format
</description> </description>
</key> </key>
</schema> </schema>
</schemalist> </schemalist>

16
data/meson.build
View File

@ -1,12 +1,12 @@
if build_gui if build_gui
i18n.merge_file( i18n.merge_file(
input: 'tuf-manager.desktop.in', input: 'tuf-manager.desktop.in',
output: 'tuf-manager.desktop', output: 'tuf-manager.desktop',
po_dir: join_paths(meson.source_root(), 'po'), po_dir: join_paths(meson.source_root(), 'po'),
type: 'desktop', type: 'desktop',
install: true, install: true,
install_dir: join_paths(get_option('datadir'), 'applications') install_dir: join_paths(get_option('datadir'), 'applications')
) )
endif endif
subdir('dbus') subdir('dbus')

16
data/polkit/meson.build
View File

@ -1,10 +1,10 @@
if not always_authenticated if not always_authenticated
i18n.merge_file( i18n.merge_file(
input: 'org.tuf.manager.policy.in', input: 'org.tuf.manager.policy.in',
output: 'org.tuf.manager.policy', output: 'org.tuf.manager.policy',
po_dir: join_paths(meson.source_root(), 'po'), po_dir: join_paths(meson.source_root(), 'po'),
type: 'xml', type: 'xml',
install: true, install: true,
install_dir: join_paths(get_option('datadir'), 'polkit-1', 'actions') install_dir: join_paths(get_option('datadir'), 'polkit-1', 'actions')
) )
endif endif

26
data/polkit/org.tuf.manager.policy.in
View File

@ -1,17 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE policyconfig PUBLIC <!DOCTYPE policyconfig PUBLIC
"-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN" "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
"http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd"> "http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">
<policyconfig> <policyconfig>
<vendor>TUF Manager</vendor> <vendor>TUF Manager</vendor>
<vendor_url>https://git.cromer.cl/cromer/tuf-manager/</vendor_url> <vendor_url>https://git.cromer.cl/cromer/tuf-manager/</vendor_url>
<icon_name>package-x-generic</icon_name> <icon_name>tuf-manager</icon_name>
<action id="org.tuf.manager.save"> <action id="org.tuf.manager.save">
<message>Authentication is required</message> <message>Authentication is required</message>
<defaults> <defaults>
<allow_any>no</allow_any> <allow_any>no</allow_any>
<allow_inactive>auth_admin_keep</allow_inactive> <allow_inactive>auth_admin_keep</allow_inactive>
<allow_active>auth_admin_keep</allow_active> <allow_active>auth_admin_keep</allow_active>
</defaults> </defaults>
</action> </action>
</policyconfig> </policyconfig>

78
docs/meson.build
View File

@ -1,44 +1,44 @@
docs_enabled = get_option('valadocs') docs_enabled = get_option('valadocs')
if docs_enabled if docs_enabled
valadoc = find_program('valadoc', required: docs_enabled) valadoc = find_program('valadoc', required: docs_enabled)
vala_doc_sources = server_vala_sources vala_doc_sources = server_vala_sources
if build_cli if build_cli
vala_doc_sources += cli_vala_sources vala_doc_sources += cli_vala_sources
endif endif
if build_gui if build_gui
vala_doc_sources += gui_vala_sources vala_doc_sources += gui_vala_sources
endif endif
vala_doc_sources += error_vala_sources vala_doc_sources += error_vala_sources
vala_doc_sources += config_data_file vala_doc_sources += config_data_file
valadocs_deps = get_option('valadocs-deps') valadocs_deps = get_option('valadocs-deps')
docs_deps = [ docs_deps = [
'--pkg=polkit-gobject-1', '--pkg=polkit-gobject-1',
'--pkg=posix', '--pkg=posix',
'--pkg=gtk+-3.0' '--pkg=gtk+-3.0'
] ]
if valadocs_deps if valadocs_deps
docs_deps += ['--deps'] docs_deps += ['--deps']
endif endif
custom_target( custom_target(
'valadoc', 'valadoc',
input: vala_doc_sources, input: vala_doc_sources,
output: 'valadoc', output: 'valadoc',
command: [ valadoc, command: [ valadoc,
docs_deps, docs_deps,
'--doclet=html', '--doclet=html',
'--internal', '--internal',
'--private', '--private',
'--force', '--force',
'--package-name=@0@'.format(meson.project_name()), '--package-name=@0@'.format(meson.project_name()),
'--package-version=@0@'.format(meson.project_version()), '--package-version=@0@'.format(meson.project_version()),
'--vapidir=@0@'.format(join_paths(meson.source_root(), 'vapi')), '--vapidir=@0@'.format(join_paths(meson.source_root(), 'vapi')),
'--directory=@OUTDIR@/valadoc', '--directory=@OUTDIR@/valadoc',
vala_doc_sources vala_doc_sources
], ],
build_by_default: true, build_by_default: true,
install: true, install: true,
install_dir: join_paths(get_option('datadir'), 'doc', meson.project_name()) install_dir: join_paths(get_option('datadir'), 'doc', meson.project_name())
) )
endif endif
install_data('../LICENSE', install_dir: join_paths(get_option('datadir'), 'doc', meson.project_name())) install_data('../LICENSE', install_dir: join_paths(get_option('datadir'), 'doc', meson.project_name()))

32
meson.build
View File

@ -1,29 +1,31 @@
project( project(
'tuf-manager', 'tuf-manager',
[ [
'c', 'c',
'vala' 'vala'
], ],
version: '0.1.0', version: '0.1.0',
license: 'BSD-3', license: 'BSD-3',
default_options: default_options:
[ [
'b_ndebug=if-release', 'b_ndebug=if-release',
'c_std=c18', 'c_std=c18',
'warning_level=3' 'warning_level=3'
] ]
) )
add_global_arguments( add_global_arguments(
'-DGETTEXT_PACKAGE="@0@"'.format(meson.project_name()), '-DGETTEXT_PACKAGE="@0@"'.format(meson.project_name()),
language: 'c' language: 'c'
) )
always_authenticated = get_option('always-authenticated') always_authenticated = get_option('always-authenticated')
build_cli = get_option('build-cli') build_cli = get_option('build-cli')
build_gui = get_option('build-gui') build_gui = get_option('build-gui')
openrc = get_option('openrc')
subdir('po') subdir('po')
subdir('data') subdir('data')
subdir('src') subdir('src')
subdir('docs') subdir('docs')
subdir('script') subdir('script')
subdir('contrib')

46
meson_options.txt
View File

@ -1,30 +1,36 @@
option( option(
'valadocs', 'valadocs',
type: 'boolean', type: 'boolean',
value: true, value: true,
description: 'Build valadocs' description: 'Build valadocs'
) )
option( option(
'valadocs-deps', 'valadocs-deps',
type: 'boolean', type: 'boolean',
value: false, value: false,
description: 'Build the valadocs of the dependencies' description: 'Build the valadocs of the dependencies'
) )
option( option(
'build-cli', 'build-cli',
type : 'boolean', type : 'boolean',
value: true, value: true,
description: 'Build the command line interface to TUF Manager' description: 'Build the command line interface to TUF Manager'
) )
option( option(
'build-gui', 'build-gui',
type : 'boolean', type : 'boolean',
value: true, value: true,
description: 'Build the graphical user interface to TUF Manager' description: 'Build the graphical user interface to TUF Manager'
) )
option( option(
'always-authenticated', 'always-authenticated',
type : 'boolean', type : 'boolean',
value: true, value: true,
description: 'User is always authenticated, so no password is necessary' description: 'User is always authenticated, so no password is necessary'
)
option(
'openrc',
type : 'boolean',
value: false,
description: 'Install OpenRC script'
) )

12
po/meson.build
View File

@ -1,9 +1,9 @@
i18n = import('i18n') i18n = import('i18n')
i18n.gettext( i18n.gettext(
meson.project_name(), meson.project_name(),
args: args:
[ [
'--directory=' + meson.source_root(), '--directory=' + meson.source_root(),
'--from-code=UTF-8' '--from-code=UTF-8'
] ]
) )

2
script/meson.build
View File

@ -1,5 +1,5 @@
# only gui or cli need gschema # only gui or cli need gschema
if build_gui or build_cli if build_gui or build_cli
valadoc = find_program('glib-compile-schemas') glib_compile_schemas = find_program('glib-compile-schemas')
meson.add_install_script('compile_schemas.sh') meson.add_install_script('compile_schemas.sh')
endif endif

824
src/cli.vala
View File

@ -16,406 +16,524 @@
* The TUF Manager namespace * The TUF Manager namespace
*/ */
namespace TUFManager { namespace TUFManager {
/** /**
* The CLI namespace handles all command line related usage * The CLI namespace handles all command line related usage
*/ */
namespace CLI { namespace CLI {
public class TUFManagerApp : Application { /**
* This class contains the app that runs on the command line
*/
public class TUFManagerApp : Application {
#if ALWAYS_AUTHENTICATED #if ALWAYS_AUTHENTICATED
#else #else
/** /**
* The subprocess that will contain our tty polkit agent * The subprocess that will contain our tty polkit agent
*/ */
Subprocess? pkttyagent = null; Subprocess? pkttyagent = null;
#endif #endif
private enum FanMode { /**
BALANCED, * The possible modes the fan can be in
TURBO, */
SILENT private enum FanMode {
} /**
* This is the default fan mode
*/
BALANCED,
/**
* This mode makes the fans run at full power
*/
TURBO,
/**
* This mode trys to keep the fans as quiet as possible
*/
SILENT
}
private enum KeyboardMode { /**
STATIC, * The possible modes the keyboard lighting can be set to
BREATHING, */
COLOR_CYCLE, private enum KeyboardMode {
STROBING /**
} * This mode makes the keyboard lights stay a constant color
*/
STATIC,
/**
* This mode makes the keyboard lights turn on and off at a variable speed
*/
BREATHING,
/**
* This mode makes the keyboard lights cycle through various colors at a variable speed
*/
COLOR_CYCLE,
/**
* This modes makes the keyboad lights strobe fast
*/
STROBING
}
private enum KeyboardSpeed { /**
SLOW, * The possible speeds that can bet set for the keyboard
MEDIUM, */
FAST private enum KeyboardSpeed {
} /**
* Slow speed
*/
SLOW,
/**
* Medium speed
*/
MEDIUM,
/**
* Fast speed
*/
FAST
}
private bool invalid = false; /**
* This flag is set if the command line arguments are invalid
*/
private bool invalid = false;
private bool help = false; /**
private bool info = false; * This flag is set if the user wants to see help
private bool version = false; */
private bool help = false;
private bool fan = false; /**
private FanMode? fan_mode = null; * This flag is set if the user wants to see info
*/
private bool info = false;
private bool lighting = false; /**
private KeyboardMode? keyboard_mode = null; * This flag is set if the user wants to see the version
*/
private bool version = false;
private bool speed = false; /**
private KeyboardSpeed? keyboard_speed = null; * This flag is set if the user wants to set the fan mode
*/
private bool fan = false;
private bool color = false; /**
private Gdk.RGBA? rgba = null; * This contains the mode the user want to set for the fan
*/
private FanMode? fan_mode = null;
public TUFManagerApp () { /**
Object (application_id: "cl.cromer.tuf.manager", flags: ApplicationFlags.HANDLES_COMMAND_LINE); * This flag is set if the user wants to set the keyboard lighting mode
set_inactivity_timeout (1000); */
} private bool lighting = false;
public override void activate () { /**
this.hold (); * This contains the mode the user want to set for the keyboard
this.release (); */
} private KeyboardMode? keyboard_mode = null;
private int _command_line (ApplicationCommandLine command_line) { /**
try { * This flag is set if the user wants to change the speed of the lights on the keyboard
connect_dbus (); */
} private bool speed = false;
catch (TUFError e) {
command_line.printerr (_ ("Error: ") + e.message + "\n");
}
string[] args = command_line.get_arguments (); /**
* This contains the speed of the lights on the keyboard that the user wants to set
*/
private KeyboardSpeed? keyboard_speed = null;
if (args.length == 1) { /**
help = true; * This flag is set if the user wants to change the keyboard color
} */
else if (args.length > 1) { private bool color = false;
switch (args[1]) {
case "version":
version = true;
check_second_argument (args);
break;
case "help":
help = true;
check_second_argument (args);
break;
case "info":
info = true;
check_second_argument (args);
break;
case "fan":
fan = true;
break;
case "lighting":
lighting = true;
break;
case "speed":
speed = true;
break;
case "color":
color = true;
break;
default:
invalid = true;
break;
}
if (args.length > 2) { /**
if (fan) { * This contains the color in rgba format to set
switch (args[2]) { */
case "balanced": private Gdk.RGBA? rgba = null;
fan_mode = FanMode.BALANCED;
break;
case "turbo":
fan_mode = FanMode.TURBO;
break;
case "silent":
fan_mode = FanMode.SILENT;
break;
default:
invalid = true;
break;
}
}
if (lighting) { /**
switch (args[2]) { * Initializes the command line app and sets a timeout so that the process can finish before return is called
case "static": */
keyboard_mode = KeyboardMode.STATIC; public TUFManagerApp () {
break; Object (application_id: "cl.cromer.tuf.manager", flags: ApplicationFlags.HANDLES_COMMAND_LINE);
case "breath": set_inactivity_timeout (1000);
keyboard_mode = KeyboardMode.BREATHING; }
break;
case "cycle":
keyboard_mode = KeyboardMode.COLOR_CYCLE;
break;
case "strobe":
keyboard_mode = KeyboardMode.STROBING;
break;
default:
invalid = true;
break;
}
}
if (speed) { /**
switch (args[2]) { * This is called when the application gets activated
case "slow": */
keyboard_speed = KeyboardSpeed.SLOW; public override void activate () {
break; this.hold ();
case "medium": this.release ();
keyboard_speed = KeyboardSpeed.MEDIUM; }
break;
case "fast":
keyboard_speed = KeyboardSpeed.FAST;
break;
default:
invalid = true;
break;
}
}
if (color) { /**
try { * This is the logic that controls the command lines options used
// Make sure it's a valid hex color *
Regex regex = new Regex ("^#[0-9A-F]{6}$"); * @param command_line The command line that is in use
* @return Returns 0 on success or an error code if failure
*/
private int _command_line (ApplicationCommandLine command_line) {
try {
connect_tuf_server ();
}
catch (TUFError e) {
command_line.printerr (_ ("Error: ") + e.message + "\n");
}
if (!regex.match (args[2].up ())) { string[] args = command_line.get_arguments ();
invalid = true;
}
}
catch (RegexError e) {
command_line.printerr (_ ("Error: ") + e.message + "\n");
}
finally {
rgba = Gdk.RGBA ();
rgba.parse (args[2]);
}
}
}
if (fan && fan_mode == null) { if (args.length == 1) {
invalid = true; // If no arguments are passed show help
} help = true;
}
else if (args.length > 1) {
// Find out what the first argument is
switch (args[1]) {
case "version":
version = true;
check_second_argument (args);
break;
case "help":
help = true;
check_second_argument (args);
break;
case "info":
info = true;
check_second_argument (args);
break;
case "fan":
fan = true;
break;
case "lighting":
lighting = true;
break;
case "speed":
speed = true;
break;
case "color":
color = true;
break;
default:
invalid = true;
break;
}
if (lighting && keyboard_mode == null) { if (args.length > 2) {
invalid = true; // If the first argument requires a second argument, look for it here
} if (fan) {
switch (args[2]) {
case "balanced":
fan_mode = FanMode.BALANCED;
break;
case "turbo":
fan_mode = FanMode.TURBO;
break;
case "silent":
fan_mode = FanMode.SILENT;
break;
default:
invalid = true;
break;
}
}
if (speed && keyboard_speed == null) { if (lighting) {
invalid = true; switch (args[2]) {
} case "static":
keyboard_mode = KeyboardMode.STATIC;
break;
case "breath":
keyboard_mode = KeyboardMode.BREATHING;
break;
case "cycle":
keyboard_mode = KeyboardMode.COLOR_CYCLE;
break;
case "strobe":
keyboard_mode = KeyboardMode.STROBING;
break;
default:
invalid = true;
break;
}
}
if (color && rgba == null) { if (speed) {
invalid = true; switch (args[2]) {
} case "slow":
} keyboard_speed = KeyboardSpeed.SLOW;
break;
case "medium":
keyboard_speed = KeyboardSpeed.MEDIUM;
break;
case "fast":
keyboard_speed = KeyboardSpeed.FAST;
break;
default:
invalid = true;
break;
}
}
if (invalid) { if (color) {
command_line.printerr (_ ("Invalid arguments!\n\n")); try {
print_usage (command_line); // Make sure it's a valid hex color
release_cli (); Regex regex = new Regex ("^#[0-9A-F]{6}$");
return 1;
} if (!regex.match (args[2].up ())) {
else if (version) { invalid = true;
command_line.print (_ ("Version: ") + VERSION + "\n"); }
release_cli (); }
return 0; catch (RegexError e) {
} command_line.printerr (_ ("Error: ") + e.message + "\n");
else if (help) { }
print_usage (command_line); finally {
release_cli (); rgba = Gdk.RGBA ();
return 0; rgba.parse (args[2]);
} }
else if (info) { }
command_line.print (_ ("Client version: ") + VERSION + "\n"); }
command_line.print (_ ("Server version: ") + get_server_version () + "\n");
var current_setting = get_fan_mode (); if (fan && fan_mode == null) {
switch (current_setting) { invalid = true;
case 0: }
command_line.print (_ ("Current fan mode: Balanced\n"));
break; if (lighting && keyboard_mode == null) {
case 1: invalid = true;
command_line.print (_ ("Current fan mode: Turbo\n")); }
break;
case 2: if (speed && keyboard_speed == null) {
command_line.print (_ ("Current fan mode: Silent\n")); invalid = true;
break; }
default:
command_line.printerr (_ ("Error: Could not get current fan mode!\n")); if (color && rgba == null) {
break; invalid = true;
} }
current_setting = get_keyboard_mode (); }
switch (current_setting) {
case 0: if (invalid) {
command_line.print (_ ("Current keyboard lighting: Static\n")); command_line.printerr (_ ("Invalid arguments!\n\n"));
break; print_usage (command_line);
case 1: release_cli ();
command_line.print (_ ("Current keyboard lighting: Breathing\n")); return 1;
break; }
case 2: else if (version) {
command_line.print (_ ("Current keyboard lighting: Color Cycle\n")); command_line.print (_ ("Version: ") + VERSION + "\n");
break; release_cli ();
case 3: return 0;
command_line.print (_ ("Current keyboard lighting: Strobing\n")); }
break; else if (help) {
default: print_usage (command_line);
command_line.printerr (_ ("Error: Could not get current keyboard mode!\n")); release_cli ();
break; return 0;
} }
current_setting = get_keyboard_speed (); else if (info) {
switch (current_setting) { command_line.print (_ ("Client version: ") + VERSION + "\n");
case 0: command_line.print (_ ("Server version: ") + get_server_version () + "\n");
command_line.print (_ ("Current keyboard speed: Slow\n")); var current_setting = get_fan_mode ();
break; switch (current_setting) {
case 1: case 0:
command_line.print (_ ("Current keyboard speed: Medium\n")); command_line.print (_ ("Current fan mode: Balanced\n"));
break; break;
case 2: case 1:
command_line.print (_ ("Current keyboard speed: Fast\n")); command_line.print (_ ("Current fan mode: Turbo\n"));
break; break;
default: case 2:
command_line.printerr (_ ("Error: Could not get current fan mode!\n")); command_line.print (_ ("Current fan mode: Silent\n"));
break; break;
} default:
var current_color = get_keyboard_color (); command_line.printerr (_ ("Error: Could not get current fan mode!\n"));
var color_hex = "#%02x%02x%02x".printf ( break;
(uint) (Math.round (current_color.red * 255)), }
(uint) (Math.round (current_color.green * 255)), current_setting = get_keyboard_mode ();
(uint) (Math.round (current_color.blue * 255)) switch (current_setting) {
).up (); case 0:
command_line.print (_ ("Current keyboard color: " + color_hex + "\n")); command_line.print (_ ("Current keyboard lighting: Static\n"));
release_cli (); break;
return 0; case 1:
} command_line.print (_ ("Current keyboard lighting: Breathing\n"));
else if (fan) { break;
case 2:
command_line.print (_ ("Current keyboard lighting: Color Cycle\n"));
break;
case 3:
command_line.print (_ ("Current keyboard lighting: Strobing\n"));
break;
default:
command_line.printerr (_ ("Error: Could not get current keyboard mode!\n"));
break;
}
current_setting = get_keyboard_speed ();
switch (current_setting) {
case 0:
command_line.print (_ ("Current keyboard speed: Slow\n"));
break;
case 1:
command_line.print (_ ("Current keyboard speed: Medium\n"));
break;
case 2:
command_line.print (_ ("Current keyboard speed: Fast\n"));
break;
default:
command_line.printerr (_ ("Error: Could not get current fan mode!\n"));
break;
}
var current_color = get_keyboard_color ();
var color_hex = "#%02x%02x%02x".printf (
(uint) (Math.round (current_color.red * 255)),
(uint) (Math.round (current_color.green * 255)),
(uint) (Math.round (current_color.blue * 255))
).up ();
command_line.print (_ ("Current keyboard color: " + color_hex + "\n"));
release_cli ();
return 0;
}
else if (fan) {
#if ALWAYS_AUTHENTICATED #if ALWAYS_AUTHENTICATED
int mode = fan_mode; int mode = fan_mode;
tuf_server.procedure_finished.connect (release_cli); tuf_server.procedure_finished.connect (release_cli);
set_fan_mode (mode); set_fan_mode (mode);
#else #else
try { try {
pkttyagent = new Subprocess.newv ({"pkttyagent"}, SubprocessFlags.NONE); pkttyagent = new Subprocess.newv ({"pkttyagent"}, SubprocessFlags.NONE);
Timeout.add (200, () => { Timeout.add (200, () => {
int mode = fan_mode; int mode = fan_mode;
tuf_server.procedure_finished.connect (release_cli); tuf_server.procedure_finished.connect (release_cli);
set_fan_mode (mode); set_fan_mode (mode);
return false; return false;
}); });
} }
catch (Error e) { catch (Error e) {
command_line.printerr (_ ("Error: ") + e.message + "\n"); command_line.printerr (_ ("Error: ") + e.message + "\n");
} }
#endif #endif
return 0; return 0;
} }
else if (lighting) { else if (lighting) {
#if ALWAYS_AUTHENTICATED #if ALWAYS_AUTHENTICATED
int mode = keyboard_mode; int mode = keyboard_mode;
tuf_server.procedure_finished.connect (release_cli); tuf_server.procedure_finished.connect (release_cli);
set_keyboard_mode (mode); set_keyboard_mode (mode);
#else #else
try { try {
pkttyagent = new Subprocess.newv ({"pkttyagent"}, SubprocessFlags.NONE); pkttyagent = new Subprocess.newv ({"pkttyagent"}, SubprocessFlags.NONE);
Timeout.add (200, () => { Timeout.add (200, () => {
int mode = keyboard_mode; int mode = keyboard_mode;
tuf_server.procedure_finished.connect (release_cli); tuf_server.procedure_finished.connect (release_cli);
set_keyboard_mode (mode); set_keyboard_mode (mode);
return false; return false;
}); });
} }
catch (Error e) { catch (Error e) {
command_line.printerr (_ ("Error: ") + e.message + "\n"); command_line.printerr (_ ("Error: ") + e.message + "\n");
} }
#endif #endif
return 0; return 0;
} }
else if (speed) { else if (speed) {
#if ALWAYS_AUTHENTICATED #if ALWAYS_AUTHENTICATED
int set_speed = keyboard_speed; int set_speed = keyboard_speed;
tuf_server.procedure_finished.connect (release_cli); tuf_server.procedure_finished.connect (release_cli);
set_keyboard_speed (set_speed); set_keyboard_speed (set_speed);
#else #else
try { try {
pkttyagent = new Subprocess.newv ({"pkttyagent"}, SubprocessFlags.NONE); pkttyagent = new Subprocess.newv ({"pkttyagent"}, SubprocessFlags.NONE);
Timeout.add (200, () => { Timeout.add (200, () => {
int set_speed = keyboard_speed; int set_speed = keyboard_speed;
tuf_server.procedure_finished.connect (release_cli); tuf_server.procedure_finished.connect (release_cli);
set_keyboard_speed (set_speed); set_keyboard_speed (set_speed);
return false; return false;
}); });
} }
catch (Error e) { catch (Error e) {
command_line.printerr (_ ("Error: ") + e.message + "\n"); command_line.printerr (_ ("Error: ") + e.message + "\n");
} }
#endif #endif
return 0; return 0;
} }
else if (color) { else if (color) {
#if ALWAYS_AUTHENTICATED #if ALWAYS_AUTHENTICATED
tuf_server.procedure_finished.connect (release_cli); tuf_server.procedure_finished.connect (release_cli);
set_keyboard_color (rgba); set_keyboard_color (rgba);
#else #else
try { try {
pkttyagent = new Subprocess.newv ({"pkttyagent"}, SubprocessFlags.NONE); pkttyagent = new Subprocess.newv ({"pkttyagent"}, SubprocessFlags.NONE);
Timeout.add (200, () => { Timeout.add (200, () => {
tuf_server.procedure_finished.connect (release_cli); tuf_server.procedure_finished.connect (release_cli);
set_keyboard_color (rgba); set_keyboard_color (rgba);
return false; return false;
}); });
} }
catch (Error e) { catch (Error e) {
command_line.printerr (_ ("Error: ") + e.message + "\n"); command_line.printerr (_ ("Error: ") + e.message + "\n");
} }
#endif #endif
return 0; return 0;
} }
return 0; return 0;
} }
private void check_second_argument (string[] args) { /**
if (args.length > 2) { * If there are more arguments than there should be we need to invalidate
invalid = true; * TODO: Change this to something better later
} *
} * @param args The arguments to check the length on
*/
private void check_second_argument (string[] args) {
if (args.length > 2) {
invalid = true;
}
}
private void print_usage (ApplicationCommandLine command_line) { /**
command_line.print ("Usage: tuf-cli COMMAND [SUBCOMMAND] ...\n\n"); * Print the usage for the user if help is called or they do something invalid
command_line.print (" version Print the version of tuf-cli\n"); *
command_line.print (" help Show this help screen\n"); * @param command_line The command line currently in use to print to
command_line.print (" fan [balanced, turbo, silent] Set the fan mode\n"); */
command_line.print (" lighting [static, breath, cycle, stobe] Set the keyboard lighting\n"); private void print_usage (ApplicationCommandLine command_line) {
command_line.print (" speed [slow, medium, fast] Set the keyboard lighting speed\n"); command_line.print ("Usage: tuf-cli COMMAND [SUBCOMMAND] ...\n\n");
command_line.print (" color [\"#XXXXXX\"] Set the keyboard color\n"); command_line.print (" version Print the version of tuf-cli\n");
command_line.print (" info Show the current config\n\n"); command_line.print (" help Show this help screen\n");
command_line.print ("Examples:\n"); command_line.print (" fan [balanced, turbo, silent] Set the fan mode\n");
command_line.print (" Silence fan: tuf-cli fan silent\n"); command_line.print (" lighting [static, breath, cycle, stobe] Set the keyboard lighting\n");
command_line.print (" Change RGB color: tuf-cli color \"#FF0000\"\n"); command_line.print (" speed [slow, medium, fast] Set the keyboard lighting speed\n");
} command_line.print (" color [\"#XXXXXX\"] Set the keyboard color\n");
command_line.print (" info Show the current config\n\n");
command_line.print ("Examples:\n");
command_line.print (" Silence fan: tuf-cli fan silent\n");
command_line.print (" Change RGB color: tuf-cli color \"#FF0000\"\n");
}
/** /**
* This method releases the command line program from it's loop * This method releases the command line program from it's hold
*/ * This will should be called when by a signal from the server to release the program
public void release_cli () { */
public void release_cli () {
#if ALWAYS_AUTHENTICATED #if ALWAYS_AUTHENTICATED
#else #else
if (pkttyagent != null) { if (pkttyagent != null) {
pkttyagent.force_exit (); pkttyagent.force_exit ();
} }
#endif #endif
this.release (); this.release ();
} }
public override int command_line (ApplicationCommandLine command_line) { /**
// keep the application running until we are done with this commandline * The command line application starts here, we hold it in a loop until
this.hold (); * the serve responds and releases
int res = _command_line (command_line); *
return res; * @param command_line The command line that is going to be used
} * @return Returns the status code from our command line program
} */
} public override int command_line (ApplicationCommandLine command_line) {
// keep the application running until we are done with this commandline
this.hold ();
int res = _command_line (command_line);
return res;
}
}
}
} }

296
src/common.vala
View File

@ -16,133 +16,193 @@
* The TUF Manager namespace * The TUF Manager namespace
*/ */
namespace TUFManager { namespace TUFManager {
private TUFServerInterface tuf_server; /**
private BusName bus_name; * The TUF Server interface that is running in the background
*/
private TUFServerInterface tuf_server;
private void connect_dbus () throws TUFError { /**
bus_name = new BusName ("org.tuf.manager"); * The bus name to send to the server to identify itself
connect_tuf_server (); */
if (get_server_version () != VERSION) { private BusName bus_name;
throw new TUFError.UNMATCHED_VERSIONS ("The server and client versions do not match!");
}
}
private void connect_tuf_server () { /**
try { * Connect to the TUF Server daemon via dbus
tuf_server = Bus.get_proxy_sync (BusType.SYSTEM, "org.tuf.manager.server", "/org/tuf/manager/server"); *
} * @throws TUFError Thrown when the server and the client versions don't match
catch (IOError e) { */
stderr.printf ("Error: %s\n", e.message); private void connect_tuf_server () throws TUFError {
} bus_name = new BusName ("org.tuf.manager");
}
private string? get_server_version () { try {
try { tuf_server = Bus.get_proxy_sync (BusType.SYSTEM, "org.tuf.manager.server", "/org/tuf/manager/server");
return tuf_server.get_server_version (); }
} catch (IOError e) {
catch (Error e) { stderr.printf (_ ("Error: %s\n"), e.message);
stderr.printf ("Error: %s\n", e.message); }
}
return null;
}
private int get_fan_mode () { string? server_version = get_server_version ();
try { if (server_version == null) {
return tuf_server.get_fan_mode (); return;
} }
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
return -3;
}
private void set_fan_mode (int mode) { if (server_version != VERSION) {
try { throw new TUFError.UNMATCHED_VERSIONS (_ ("The server and client versions do not match!"));
tuf_server.set_fan_mode (mode, bus_name); }
} }
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
private Gdk.RGBA get_keyboard_color () { /**
try { * Get the server version from the running daemon
return tuf_server.get_keyboard_color (); *
} * @return Returns a string containing the server version or null on failure
catch (TUFError e) { */
stderr.printf ("Error: %s\n", e.message); private string? get_server_version () {
} try {
catch (Error e) { return tuf_server.get_server_version ();
stderr.printf ("Error: %s\n", e.message); }
} catch (Error e) {
return Gdk.RGBA (); stderr.printf (_ ("Error: %s\n"), e.message);
} }
return null;
}
private void set_keyboard_color (Gdk.RGBA color) { /**
try { * Get the mode the fan is in
tuf_server.set_keyboard_color (color, bus_name); *
} * @return Returns the fan mode or -3 on error
catch (TUFError e) { */
stderr.printf ("Error: %s\n", e.message); private int get_fan_mode () {
} try {
catch (Error e) { return tuf_server.get_fan_mode ();
stderr.printf ("Error: %s\n", e.message); }
} catch (TUFError e) {
} stderr.printf (_ ("Error: %s\n"), e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
return -3;
}
private int get_keyboard_mode () { /**
try { * Set the fan mode
return tuf_server.get_keyboard_mode (); *
} * @param mode The new mode to set
catch (TUFError e) { */
stderr.printf ("Error: %s\n", e.message); private void set_fan_mode (int mode) {
} try {
catch (Error e) { tuf_server.set_fan_mode (mode, bus_name);
stderr.printf ("Error: %s\n", e.message); }
} catch (TUFError e) {
return -3; stderr.printf ("Error: %s\n", e.message);
} }
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
private void set_keyboard_mode (int mode) { /**
try { * Get the current keyboard color
tuf_server.set_keyboard_mode (mode, bus_name); *
} * @return Returns an RGBA struct containing the keyboard color or an initialized RGBA struct on error
catch (TUFError e) { */
stderr.printf ("Error: %s\n", e.message); private Gdk.RGBA get_keyboard_color () {
} try {
catch (Error e) { return tuf_server.get_keyboard_color ();
stderr.printf ("Error: %s\n", e.message); }
} catch (TUFError e) {
} stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
return Gdk.RGBA ();
}
private int get_keyboard_speed () { /**
try { * Set a new keyboard color
return tuf_server.get_keyboard_speed (); *
} * @param color An RGBA struct containing the new color to set
catch (TUFError e) { */
stderr.printf ("Error: %s\n", e.message); private void set_keyboard_color (Gdk.RGBA color) {
} try {
catch (Error e) { tuf_server.set_keyboard_color (color, bus_name);
stderr.printf ("Error: %s\n", e.message); }
} catch (TUFError e) {
return -3; stderr.printf ("Error: %s\n", e.message);
} }
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
private void set_keyboard_speed (int speed) { /**
try { * Get the current lighting mode of the keyboard
tuf_server.set_keyboard_speed (speed, bus_name); *
} * @return Returns the current keyboard lighting mode or -3 on error
catch (TUFError e) { */
stderr.printf ("Error: %s\n", e.message); private int get_keyboard_mode () {
} try {
catch (Error e) { return tuf_server.get_keyboard_mode ();
stderr.printf ("Error: %s\n", e.message); }
} catch (TUFError e) {
} stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
return -3;
}
/**
* Set the keyboard lighting mode
*
* @param mode The new mode to set for the keyboard lighting
*/
private void set_keyboard_mode (int mode) {
try {
tuf_server.set_keyboard_mode (mode, bus_name);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
/**
* Get the current keyboard lighting speed
*
* @return Returns the current speed or -3 on error
*/
private int get_keyboard_speed () {
try {
return tuf_server.get_keyboard_speed ();
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
return -3;
}
/**
* Set a new keyboard lighting speed
*
* @param speed The new speed to set
*/
private void set_keyboard_speed (int speed) {
try {
tuf_server.set_keyboard_speed (speed, bus_name);
}
catch (TUFError e) {
stderr.printf ("Error: %s\n", e.message);
}
catch (Error e) {
stderr.printf ("Error: %s\n", e.message);
}
}
} }

68
src/config.vala.in
View File

@ -16,23 +16,53 @@
* The TUF Manager namespace * The TUF Manager namespace
*/ */
namespace TUFManager { namespace TUFManager {
/** /**
* The package name used for translations * The package name used for translations
*/ */
public const string GETTEXT_PACKAGE = "@GETTEXT_PACKAGE@"; public const string GETTEXT_PACKAGE = "@GETTEXT_PACKAGE@";
/**
* The version of the application /**
*/ * The version of the application
public const string VERSION = "@VERSION@"; */
/** public const string VERSION = "@VERSION@";
* The location of the thermal control
*/ /**
public const string THERMAL_PATH = "/sys/devices/platform/faustus/throttle_thermal_policy"; * The location of the thermal control
public const string RED_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_red"; */
public const string GREEN_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_green"; public const string THERMAL_PATH = "/sys/devices/platform/faustus/throttle_thermal_policy";
public const string BLUE_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_blue";
public const string KEYBOARD_MODE_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_mode"; /**
public const string KEYBOARD_FLAGS_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_flags"; * The location of the red hue control
public const string KEYBOARD_SPEED_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_speed"; */
public const string KEYBOARD_SET_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_set"; public const string RED_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_red";
/**
* The location of the green hue control
*/
public const string GREEN_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_green";
/**
* The location of the blue hue control
*/
public const string BLUE_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_blue";
/**
* The location of the keyboard mode control
*/
public const string KEYBOARD_MODE_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_mode";
/**
* The location of the flags for the keyboard control
*/
public const string KEYBOARD_FLAGS_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_flags";
/**
* The location of the keyboard lighting speed control
*/
public const string KEYBOARD_SPEED_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_speed";
/**
* The location of the keyboard set control
*/
public const string KEYBOARD_SET_PATH = "/sys/devices/platform/faustus/kbbl/kbbl_set";
} }

50
src/error.vala
View File

@ -16,29 +16,29 @@
* The TUF Manager namespace * The TUF Manager namespace
*/ */
namespace TUFManager { namespace TUFManager {
/** /**
* This contains errors related to TUF Manager * This contains errors related to TUF Manager
*/ */
public errordomain TUFError { public errordomain TUFError {
/** /**
* The stream failed to open * The stream failed to open
*/ */
STREAM, STREAM,
/** /**
* An invalid value was returned * An invalid value was returned
*/ */
INVALID_VALUE, INVALID_VALUE,
/** /**
* The server is busy and can't do another task yet * The server is busy and can't do another task yet
*/ */
BUSY, BUSY,
/** /**
* The client and serer version don't match * The client and serer version don't match
*/ */
UNMATCHED_VERSIONS, UNMATCHED_VERSIONS,
/** /**
* The user is unauthorized to perform that action * The user is unauthorized to perform that action
*/ */
UNAUTHORIZED UNAUTHORIZED
} }
} }

432
src/gui-window.vala
View File

@ -16,232 +16,254 @@
* The TUF Manager namespace * The TUF Manager namespace
*/ */
namespace TUFManager { namespace TUFManager {
/** /**
* The GUI namespace contains a GTK based interface to interact with the TUF laptop * The GUI namespace contains a GTK based interface to interact with the TUF laptop
*/ */
namespace GUI { namespace GUI {
/** /**
* The main window to show to the user * The main window to show to the user
*/ */
[GtkTemplate (ui = "/cl/cromer/tuf-manager/tuf.manager.window.ui")] [GtkTemplate (ui = "/cl/cromer/tuf-manager/tuf.manager.window.ui")]
public class MainWindow : Gtk.ApplicationWindow { public class MainWindow : Gtk.ApplicationWindow {
/** /**
* This is used to make sure that the sysfs files are not written to until everything is initialized * This is used to make sure that the sysfs files are not written to until everything is initialized
*/ */
private bool initialized = false; private bool initialized = false;
private Settings settings;
/** /**
* The fan mode combo box * The settings object from gschema/dconf
*/ */
[GtkChild] private Settings settings;
private Gtk.ComboBoxText fan_mode;
[GtkChild] /**
private Gtk.ComboBoxText keyboard_mode; * The fan mode combo box
*/
[GtkChild]
private Gtk.ComboBoxText fan_mode;
[GtkChild] /**
private Gtk.ComboBoxText keyboard_speed; * They keyboard mode combo box
*/
[GtkChild]
private Gtk.ComboBoxText keyboard_mode;
/** /**
* The color chooser widget * The keyboard speed combox box
*/ */
[GtkChild] [GtkChild]
private Gtk.ColorChooserWidget keyboard_color; private Gtk.ComboBoxText keyboard_speed;
/** /**
* Create the main window * The color chooser widget
* @param application The application used to make the GLib object */
*/ [GtkChild]
public MainWindow (Gtk.Application application) { private Gtk.ColorChooserWidget keyboard_color;
Object (application: application);
}
public void initialize () { /**
settings = new Settings ("org.tuf.manager"); * Create the main window
try { * @param application The application used to make the GLib object
connect_dbus (); */
} public MainWindow (Gtk.Application application) {
catch (TUFError e) { Object (application: application);
stderr.printf ("Error: %s:\n", e.message); }
if (e.code == TUFError.UNMATCHED_VERSIONS) {
Gtk.MessageDialog msg;
msg = new Gtk.MessageDialog (this,
Gtk.DialogFlags.MODAL,
Gtk.MessageType.ERROR,
Gtk.ButtonsType.CLOSE,
_ ("The current running tuf-server version doesn't match the gui version!"));
msg.response.connect ((response_id) => {
msg.destroy ();
this.close ();
});
msg.show ();
}
}
finally {
print (_ ("Client version: ") + VERSION + "\n");
print (_ ("Server version: ") + get_server_version () + "\n");
if (settings.get_boolean ("restore")) { /**
restore (); * This is called after the window is created to initialize it's interface
} */
else { public void initialize () {
// Get the fan speed settings = new Settings ("org.tuf.manager");
// 0 - normal try {
// 1 - boost connect_tuf_server ();
// 2 - silent }
var mode = get_fan_mode (); catch (TUFError e) {
if (mode >= 0) { stderr.printf ("Error: %s:\n", e.message);
fan_mode.set_active (mode); if (e.code == TUFError.UNMATCHED_VERSIONS) {
print (_ ("Current fan mode: ") + fan_mode.get_active_text () + "\n"); Gtk.MessageDialog msg;
} msg = new Gtk.MessageDialog (this,
else { Gtk.DialogFlags.MODAL,
stderr.printf ("%s\n", _ ("Error: Could not get current fan mode!")); Gtk.MessageType.ERROR,
} Gtk.ButtonsType.CLOSE,
_ ("The current running tuf-server version doesn't match the gui version!"));
msg.response.connect ((response_id) => {
msg.destroy ();
this.close ();
});
msg.show ();
}
}
finally {
print (_ ("Client version: ") + VERSION + "\n");
print (_ ("Server version: ") + get_server_version () + "\n");
// Get the keyboard mode if (settings.get_boolean ("restore")) {
mode = get_keyboard_mode (); restore ();
if (mode >= 0) { }
keyboard_mode.set_active (mode); else {
if (mode == 2) { // Get the fan speed
keyboard_color.sensitive = false; var mode = get_fan_mode ();
} if (mode >= 0) {
if (mode == 0 || mode == 3) { fan_mode.set_active (mode);
keyboard_speed.sensitive = false; print (_ ("Current fan mode: ") + fan_mode.get_active_text () + "\n");
} }
print (_ ("Current keyboard mode: ") + keyboard_mode.get_active_text () + "\n"); else {
} stderr.printf ("%s\n", _ ("Error: Could not get current fan mode!"));
else { }
stderr.printf ("%s\n", _ ("Error: Could not get current keyboard mode!"));
}
// Get the keyboard speed // Get the keyboard mode
var speed = get_keyboard_speed (); mode = get_keyboard_mode ();
if (speed >= 0) { if (mode >= 0) {
keyboard_speed.set_active (mode); keyboard_mode.set_active (mode);
print (_ ("Current keyboard speed: ") + keyboard_speed.get_active_text () + "\n"); if (mode == 2) {
} keyboard_color.sensitive = false;
else { }
stderr.printf ("%s\n", _ ("Error: Could not get current keyboard speed!")); if (mode == 0 || mode == 3) {
} keyboard_speed.sensitive = false;
}
print (_ ("Current keyboard mode: ") + keyboard_mode.get_active_text () + "\n");
}
else {
stderr.printf ("%s\n", _ ("Error: Could not get current keyboard mode!"));
}
// Get the keyboard color // Get the keyboard speed
var color = get_keyboard_color (); var speed = get_keyboard_speed ();
keyboard_color.set_rgba (color); if (speed >= 0) {
print (_ ("Current keyboard color: ") + color.to_string () + "\n"); keyboard_speed.set_active (mode);
} print (_ ("Current keyboard speed: ") + keyboard_speed.get_active_text () + "\n");
}
else {
stderr.printf ("%s\n", _ ("Error: Could not get current keyboard speed!"));
}
initialized = true; // Get the keyboard color
} var color = get_keyboard_color ();
} keyboard_color.set_rgba (color);
print (_ ("Current keyboard color: ") + color.to_string () + "\n");
}
public void restore () { initialized = true;
var mode = settings.get_int ("fan-mode"); }
if (mode >= 0 && mode <= 2) { }
if (get_fan_mode () != mode) {
set_fan_mode (mode);
}
fan_mode.set_active (mode);
}
print (_ ("Current fan mode: ") + fan_mode.get_active_text () + "\n");
mode = settings.get_int ("keyboard-mode"); /**
if (mode >= 0 && mode <= 3) { * Used to restore the previous config from donf
if (get_keyboard_mode () != mode) { * TODO: Move this to a status bar app and/or user daemon
set_keyboard_mode (mode); */
} public void restore () {
keyboard_mode.set_active (mode); var mode = settings.get_int ("fan-mode");
if (mode == 2) { if (mode >= 0 && mode <= 2) {
keyboard_color.sensitive = false; if (get_fan_mode () != mode) {
} set_fan_mode (mode);
if (mode == 0 || mode == 3) { }
keyboard_speed.sensitive = false; fan_mode.set_active (mode);
} }
} print (_ ("Current fan mode: ") + fan_mode.get_active_text () + "\n");
print (_ ("Current keyboard mode: ") + keyboard_mode.get_active_text () + "\n");
var speed = settings.get_int ("keyboard-speed"); mode = settings.get_int ("keyboard-mode");
if (speed >= 0 && speed <= 2) { if (mode >= 0 && mode <= 3) {
if (get_keyboard_speed () != speed) { if (get_keyboard_mode () != mode) {
set_keyboard_speed (speed); set_keyboard_mode (mode);
} }
keyboard_speed.set_active (speed); keyboard_mode.set_active (mode);
} if (mode == 2) {
print (_ ("Current keyboard speed: ") + keyboard_speed.get_active_text () + "\n"); keyboard_color.sensitive = false;
}
if (mode == 0 || mode == 3) {
keyboard_speed.sensitive = false;
}
}
print (_ ("Current keyboard mode: ") + keyboard_mode.get_active_text () + "\n");
var color = settings.get_string ("keyboard-color"); var speed = settings.get_int ("keyboard-speed");
var rgba = Gdk.RGBA (); if (speed >= 0 && speed <= 2) {
rgba.parse (color); if (get_keyboard_speed () != speed) {
if (!get_keyboard_color ().equal (rgba)) { set_keyboard_speed (speed);
set_keyboard_color (rgba); }
} keyboard_speed.set_active (speed);
keyboard_color.set_rgba (rgba); }
print (_ ("Current keyboard color: ") + color.to_string () + "\n"); print (_ ("Current keyboard speed: ") + keyboard_speed.get_active_text () + "\n");
}
/** var color = settings.get_string ("keyboard-color");
* Called when the user changes the fan mode var rgba = Gdk.RGBA ();
* rgba.parse (color);
* * 1 - normal mode if (!get_keyboard_color ().equal (rgba)) {
* * 2 - boost mode set_keyboard_color (rgba);
* * 3 - silent mode }
* @param combo_box The combo box that changed keyboard_color.set_rgba (rgba);
*/ print (_ ("Current keyboard color: ") + color.to_string () + "\n");
[GtkCallback] }
public void on_fan_mode_changed (Gtk.ComboBox combo_box) {
if (initialized) {
int mode = combo_box.get_active ();
set_fan_mode (mode);
settings.set_int ("fan-mode", mode); /**
} * Called when the user changes the fan mode
} *
* @param combo_box The combo box that changed
*/
[GtkCallback]
public void on_fan_mode_changed (Gtk.ComboBox combo_box) {
if (initialized) {
int mode = combo_box.get_active ();
set_fan_mode (mode);
/** settings.set_int ("fan-mode", mode);
* Called when the user changes the keyboard lighting mode }
* @param combo_box The combo box that changed }
*/
[GtkCallback]
public void on_keyboard_mode_changed (Gtk.ComboBox combo_box) {
if (initialized) {
int mode = combo_box.get_active ();
if (mode == 2) {
keyboard_color.sensitive = false;
}
else {
keyboard_color.sensitive = true;
}
if (mode == 1 || mode == 2) {
keyboard_speed.sensitive = true;
}
else {
keyboard_speed.sensitive = false;
}
set_keyboard_mode (mode);
settings.set_int ("keyboard-mode", mode); /**
} * Called when the user changes the keyboard lighting mode
} *
* @param combo_box The combo box that changed
*/
[GtkCallback]
public void on_keyboard_mode_changed (Gtk.ComboBox combo_box) {
if (initialized) {
int mode = combo_box.get_active ();
if (mode == 2) {
keyboard_color.sensitive = false;
}
else {
keyboard_color.sensitive = true;
}
if (mode == 1 || mode == 2) {
keyboard_speed.sensitive = true;
}
else {
keyboard_speed.sensitive = false;
}
set_keyboard_mode (mode);
[GtkCallback] settings.set_int ("keyboard-mode", mode);
public void on_speed_changed (Gtk.ComboBox combo_box) { }
if (initialized) { }
int speed = combo_box.get_active ();
set_keyboard_speed (speed);
settings.set_int ("keyboard-speed", speed); /**
} * Called when the user changes the keyboard lighting speed
} *
* @param combo_box The combo box that changed
*/
[GtkCallback]
public void on_speed_changed (Gtk.ComboBox combo_box) {
if (initialized) {
int speed = combo_box.get_active ();
set_keyboard_speed (speed);
[GtkCallback] settings.set_int ("keyboard-speed", speed);
public void on_set_color_clicked (Gtk.Button button) { }
if (initialized) { }
Gdk.RGBA rgba = keyboard_color.get_rgba ();
set_keyboard_color (rgba); /**
settings.set_string ("keyboard-color", rgba.to_string ()); * Called when the user clicks the set color button
} *
} * @param button The button that was clicked
} */
} [GtkCallback]
public void on_set_color_clicked (Gtk.Button button) {
if (initialized) {
Gdk.RGBA rgba = keyboard_color.get_rgba ();
set_keyboard_color (rgba);
settings.set_string ("keyboard-color", rgba.to_string ());
}
}
}
}
} }

74
src/gui.vala
View File

@ -16,45 +16,45 @@
* The TUF Manager namespace * The TUF Manager namespace
*/ */
namespace TUFManager { namespace TUFManager {
/** /**
* The GUI namespace contains a GTK based interface to interact with the TUF laptop * The GUI namespace contains a GTK based interface to interact with the TUF laptop
*/ */
namespace GUI { namespace GUI {
/** /**
* The application class * The GUI application class
*/ */
public class TUFManagerApp : Gtk.Application { public class TUFManagerApp : Gtk.Application {
/** /**
* The main application window * The main application window
*/ */
private MainWindow window; private MainWindow window;
/** /**
* Initialize the application and set it's id * Initialize the application and set it's id
*/ */
public TUFManagerApp () { public TUFManagerApp () {
application_id = "cl.cromer.tuf.manager"; application_id = "cl.cromer.tuf.manager";
} }
/** /**
* Run when the application is activated * Run when the application is activated, we call and show the window here
*/ */
public override void activate () { public override void activate () {
window = new MainWindow (this); window = new MainWindow (this);
window.icon = new Gtk.Image.from_resource ("/cl/cromer/tuf-manager/pixdata/tuf-manager.png").get_pixbuf (); window.icon = new Gtk.Image.from_resource ("/cl/cromer/tuf-manager/pixdata/tuf-manager.png").get_pixbuf ();
window.show_all (); window.show_all ();
window.initialize (); window.initialize ();
} }
/** /**
* Run when the application starts * Run when the application starts, we set the language here
*/ */
public override void startup () { public override void startup () {
Intl.textdomain (GETTEXT_PACKAGE); Intl.textdomain (GETTEXT_PACKAGE);
Intl.setlocale (LocaleCategory.ALL, ""); Intl.setlocale (LocaleCategory.ALL, "");
base.startup (); base.startup ();
} }
} }
} }
} }

40
src/main.vala.in
View File

@ -16,24 +16,24 @@
* The TUF Manager namespace * The TUF Manager namespace
*/ */
namespace TUFManager { namespace TUFManager {
/** /**
* The entry point to the TUF Manager application * The entry point to the TUF Manager UI applications
* *
* @param args Arguments passed from the command line * @param args Arguments passed from the command line
* @return Returns the status from the application * @return Returns the status from the application
*/ */
public static int main (string[] args) { public static int main (string[] args) {
var application = new @APP@.TUFManagerApp (); var application = new @APP@.TUFManagerApp ();
try { try {
application.register (); application.register ();
} }
catch (Error e) { catch (Error e) {
stderr.printf ("Error: %s\n", e.message); stderr.printf (_ ("Error: %s\n"), e.message);
} }
if (application.get_is_remote ()) { if (application.get_is_remote ()) {
stderr.printf ("Error: %s\n", _ ("Another instance of TUF Manager is already running!")); stderr.printf (_ ("Error: %s\n"), _ ("Another instance of TUF Manager is already running!"));
return -1; return -1;
} }
return application.run (args); return application.run (args);
} }
} }

168
src/meson.build
View File

@ -1,31 +1,31 @@
server_dependencies = [ server_dependencies = [
dependency('glib-2.0'), dependency('glib-2.0'),
dependency('gio-unix-2.0'), dependency('gio-unix-2.0'),
dependency('gtk+-3.0', version: '>=3.0.0'), dependency('gtk+-3.0', version: '>=3.0.0'),
meson.get_compiler('c').find_library('m', required: true), meson.get_compiler('c').find_library('m', required: true),
meson.get_compiler('vala').find_library('posix') meson.get_compiler('vala').find_library('posix')
] ]
# if not always authenticated then polkit will be used for authentication # if not always authenticated then polkit will be used for authentication
if not always_authenticated if not always_authenticated
server_dependencies += [dependency('polkit-gobject-1')] server_dependencies += [dependency('polkit-gobject-1')]
endif endif
if build_cli if build_cli
cli_dependencies = [ cli_dependencies = [
dependency('glib-2.0'), dependency('glib-2.0'),
dependency('gtk+-3.0', version: '>=3.0.0'), dependency('gtk+-3.0', version: '>=3.0.0'),
meson.get_compiler('c').find_library('m', required: true) meson.get_compiler('c').find_library('m', required: true)
] ]
endif endif
if build_gui if build_gui
gui_dependencies = [ gui_dependencies = [
dependency('glib-2.0'), dependency('glib-2.0'),
dependency('gobject-2.0'), dependency('gobject-2.0'),
dependency('gtk+-3.0', version: '>=3.10.0'), dependency('gtk+-3.0', version: '>=3.10.0'),
dependency('gmodule-2.0', version: '>=2.0') # gmodule-export-2.0 is needed to connect the handlers from glade ui dependency('gmodule-2.0', version: '>=2.0') # gmodule-export-2.0 is needed to connect the handlers from glade ui
] ]
endif endif
config_data = configuration_data() config_data = configuration_data()
@ -33,62 +33,62 @@ config_data.set('VERSION', meson.project_version())
config_data.set('GETTEXT_PACKAGE', meson.project_name()) config_data.set('GETTEXT_PACKAGE', meson.project_name())
config_data_file = configure_file( config_data_file = configure_file(
input: 'config.vala.in', input: 'config.vala.in',
output: 'config.vala', output: 'config.vala',
configuration: config_data configuration: config_data
) )
if build_cli if build_cli
config_data = configuration_data() config_data = configuration_data()
config_data.set('APP', 'CLI') config_data.set('APP', 'CLI')
cli_main_file = configure_file( cli_main_file = configure_file(
input: 'main.vala.in', input: 'main.vala.in',
output: 'cli-main.vala', output: 'cli-main.vala',
configuration: config_data configuration: config_data
) )
endif endif
if build_gui if build_gui
config_data = configuration_data() config_data = configuration_data()
config_data.set('APP', 'GUI') config_data.set('APP', 'GUI')
gui_main_file = configure_file( gui_main_file = configure_file(
input: 'main.vala.in', input: 'main.vala.in',
output: 'gui-main.vala', output: 'gui-main.vala',
configuration: config_data configuration: config_data
) )
endif endif
error_vala_sources = files( error_vala_sources = files(
'error.vala' 'error.vala'
) )
# The sources containing a main function definition are separated to prevent # The sources containing a main function definition are separated to prevent
# conflict errors when building valadoc. valadoc doesn't like multiple entry # conflict errors when building valadoc. valadoc doesn't like multiple entry
# points even if they are in different namespaces. # points even if they are in different namespaces.
server_vala_sources_main = files( server_vala_sources_main = files(
'server-main.vala' 'server-main.vala'
) )
server_vala_sources = files( server_vala_sources = files(
'server.vala', 'server.vala',
'server-interface.vala' 'server-interface.vala'
) )
if build_cli if build_cli
cli_vala_sources = files( cli_vala_sources = files(
'cli.vala', 'cli.vala',
'server-interface.vala', 'server-interface.vala',
'common.vala' 'common.vala'
) )
endif endif
if build_gui if build_gui
gui_vala_sources = files( gui_vala_sources = files(
'gui.vala', 'gui.vala',
'gui-window.vala', 'gui-window.vala',
'server-interface.vala', 'server-interface.vala',
'common.vala' 'common.vala'
) )
endif endif
server_sources = server_vala_sources server_sources = server_vala_sources
@ -97,61 +97,61 @@ server_sources += error_vala_sources
server_sources += config_data_file server_sources += config_data_file
if build_cli if build_cli
cli_sources = cli_vala_sources cli_sources = cli_vala_sources
cli_sources += cli_main_file cli_sources += cli_main_file
cli_sources += error_vala_sources cli_sources += error_vala_sources
cli_sources += config_data_file cli_sources += config_data_file
endif endif
if build_gui if build_gui
gui_sources = gui_vala_sources gui_sources = gui_vala_sources
gui_sources += gui_main_file gui_sources += gui_main_file
gui_sources += error_vala_sources gui_sources += error_vala_sources
gui_sources += [tuf_manager_gresource] gui_sources += [tuf_manager_gresource]
gui_sources += config_data_file gui_sources += config_data_file
endif endif
server_vala_args = [] server_vala_args = []
if always_authenticated if always_authenticated
server_vala_args += ['--define=ALWAYS_AUTHENTICATED'] server_vala_args += ['--define=ALWAYS_AUTHENTICATED']
endif endif
if build_cli if build_cli
cli_vala_args = [] cli_vala_args = []
if always_authenticated if always_authenticated
cli_vala_args += ['--define=ALWAYS_AUTHENTICATED'] cli_vala_args += ['--define=ALWAYS_AUTHENTICATED']
endif endif
endif endif
if build_gui if build_gui
gui_vala_args = ['--gresources='+join_paths(meson.source_root(), 'data/ui/tuf.manager.gresource.xml')] gui_vala_args = ['--gresources='+join_paths(meson.source_root(), 'data/ui/tuf.manager.gresource.xml')]
endif endif
server_exe = executable( server_exe = executable(
'tuf-server', 'tuf-server',
server_sources, server_sources,
dependencies: server_dependencies, dependencies: server_dependencies,
vala_args: server_vala_args, vala_args: server_vala_args,
install: true, install: true,
install_dir: join_paths(get_option('libexecdir'), meson.project_name()) install_dir: join_paths(get_option('libexecdir'), meson.project_name())
) )
if build_cli if build_cli
cli_exe = executable( cli_exe = executable(
'tuf-cli', 'tuf-cli',
cli_sources, cli_sources,
vala_args: cli_vala_args, vala_args: cli_vala_args,
dependencies: cli_dependencies, dependencies: cli_dependencies,
install: true install: true
) )
endif endif
if build_gui if build_gui
gui_exe = executable( gui_exe = executable(
'tuf-gui', 'tuf-gui',
gui_sources, gui_sources,
dependencies: gui_dependencies, dependencies: gui_dependencies,
vala_args: gui_vala_args, vala_args: gui_vala_args,
install: true install: true
) )
endif endif

123
src/server-interface.vala
View File

@ -16,20 +16,111 @@
* The TUF Manager namespace * The TUF Manager namespace
*/ */
namespace TUFManager { namespace TUFManager {
/** /**
* This interface defines the dbus daemon provided by the server * This interface defines the dbus daemon provided by the server
*/ */
[DBus (name = "org.tuf.manager.server")] [DBus (name = "org.tuf.manager.server")]
public interface TUFServerInterface : Object { public interface TUFServerInterface : Object {
public abstract string get_server_version () throws Error; /**
public abstract int get_fan_mode () throws Error, TUFError; * This signal is emited when a procedure finishes
public abstract void set_fan_mode (int mode, BusName sender) throws Error, TUFError; */
public abstract Gdk.RGBA get_keyboard_color () throws Error, TUFError; public signal void procedure_finished ();
public abstract void set_keyboard_color (Gdk.RGBA color, BusName sender) throws Error, TUFError;
public abstract int get_keyboard_mode () throws Error, TUFError; /**
public abstract void set_keyboard_mode (int mode, BusName sender) throws Error, TUFError; * Get the version of the currently running server
public abstract int get_keyboard_speed () throws Error, TUFError; *
public abstract void set_keyboard_speed (int speed, BusName sender) throws Error, TUFError; * @return Returns a string containing the version
public signal void procedure_finished (); * @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
} */
public abstract string get_server_version () throws Error;
/**
* Get the current fan mode
*
* @return Returns the current fan mode
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
* @throws TUFError Thrown if there is a problem reading a value from the stream
*/
public abstract int get_fan_mode () throws Error, TUFError;
/**
* Set a new fan mode
*
* * 0 - balanced mode
* * 1 - turbo mode
* * 2 - silent mode
*
* @param mode The new mode to set
* @param sender The bus that sent the request
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
* @throws TUFError Thrown if there is a problem writing a value to the stream
*/
public abstract void set_fan_mode (int mode, BusName sender) throws Error, TUFError;
/**
* Get the current keyboard color
*
* @return Returns an RGBA struct containing the color
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
* @throws TUFError Thrown if there is a problem writing a value to the stream
*/
public abstract Gdk.RGBA get_keyboard_color () throws Error, TUFError;
/**
* Set the keyboard color
*
* @param color The new RGBA color to set
* @param sender The bus that sent the request
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
* @throws TUFError Thrown if there is a problem writing a value to the stream
*/
public abstract void set_keyboard_color (Gdk.RGBA color, BusName sender) throws Error, TUFError;
/**
* Get the current keyboard mode
*
* @return Returns the mode
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
* @throws TUFError Thrown if there is a problem writing a value to the stream
*/
public abstract int get_keyboard_mode () throws Error, TUFError;
/**
* Set a new keyboard mode
*
* * 0 - static
* * 1 - breathing
* * 2 - color cycle
* * 3 - strobing
*
* @param mode The new mode to set
* @param sender The bus that sent the request
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
* @throws TUFError Thrown if there is a problem writing a value to the stream
*/
public abstract void set_keyboard_mode (int mode, BusName sender) throws Error, TUFError;
/**
* Get the current keyboard lighting speed
*
* @return The current speed
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
* @throws TUFError Thrown if there is a problem writing a value to the stream
*/
public abstract int get_keyboard_speed () throws Error, TUFError;
/**
* Set a new keyboard speed
*
* * 0 - slow
* * 1 - medium
* * 2 - fast
*
* @param speed The new speed to set
* @param sender The bus that sent the request
* @throws Error Thrown if there is a problem connecting to a dbus session or an IO error
* @throws TUFError Thrown if there is a problem writing a value to the stream
*/
public abstract void set_keyboard_speed (int speed, BusName sender) throws Error, TUFError;
}
} }

151
src/server-main.vala
View File

@ -16,86 +16,97 @@
* The TUF Manager namespace * The TUF Manager namespace
*/ */
namespace TUFManager { namespace TUFManager {
/** /**
* The server namespace contains anything releated to working as a dbus daemon * The server namespace contains anything releated to working as a dbus daemon
* and handling root related tasks * and handling root related tasks
*/ */
namespace Server { namespace Server {
private static bool foreground = false; /**
* Run the process in the foreground
*/
private static bool foreground = false;
private const OptionEntry[] options = { /**
{ "foreground", 'f', 0, OptionArg.NONE, ref foreground, N_ ("Run the daemon in the foreground"), null }, * The command line arguments available
{ null } */
}; private const OptionEntry[] options = {
{ "foreground", 'f', 0, OptionArg.NONE, ref foreground, N_ ("Run the daemon in the foreground"), null },
{ null }
};
private static void on_exit (int signum) { /**
if (loop != null) { * Called when the server should exit
loop.quit (); *
} * @param signum The signal that caused the server to exit
} */
private static void on_exit (int signum) {
if (loop != null) {
loop.quit ();
}
}
/** /**
* The entry point to the server launches a system dbus daemon * The entry point to the server launches a system dbus daemon
* *
* @param args Arguments passed from the command line * @param args Arguments passed from the command line
* @return Returns 0 on success * @return Returns 0 on success
*/ */
public static int main (string[] args) { public static int main (string[] args) {
Intl.setlocale (LocaleCategory.ALL, ""); Intl.setlocale (LocaleCategory.ALL, "");
Intl.bindtextdomain (GETTEXT_PACKAGE, "/usr/share/locale"); Intl.bindtextdomain (GETTEXT_PACKAGE, "/usr/share/locale");
Intl.bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); Intl.bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
Intl.textdomain (GETTEXT_PACKAGE); Intl.textdomain (GETTEXT_PACKAGE);
try { try {
var opt_context = new OptionContext (""); var opt_context = new OptionContext ("");
opt_context.set_translation_domain (GETTEXT_PACKAGE); opt_context.set_translation_domain (GETTEXT_PACKAGE);
opt_context.set_help_enabled (true); opt_context.set_help_enabled (true);
opt_context.add_main_entries (options, null); opt_context.add_main_entries (options, null);
opt_context.parse (ref args); opt_context.parse (ref args);
} }
catch (OptionError e) { catch (OptionError e) {
print (_ ("Error: %s\n"), e.message); print (_ ("Error: %s\n"), e.message);
print (_ ("Run '%s --help' to see a full list of available command line options.\n"), args[0]); print (_ ("Run '%s --help' to see a full list of available command line options.\n"), args[0]);
return 1; return 1;
} }
if (!foreground) { if (!foreground) {
var pid = Posix.fork (); var pid = Posix.fork ();
if (pid < 0) { if (pid < 0) {
Posix.exit (Posix.EXIT_FAILURE); Posix.exit (Posix.EXIT_FAILURE);
} }
else if (pid > 0) { else if (pid > 0) {
Posix.exit (Posix.EXIT_SUCCESS); Posix.exit (Posix.EXIT_SUCCESS);
} }
Posix.umask (0); Posix.umask (0);
var sid = Posix.setsid (); var sid = Posix.setsid ();
if (sid < 0) { if (sid < 0) {
Posix.exit (Posix.EXIT_FAILURE); Posix.exit (Posix.EXIT_FAILURE);
} }
if (Posix.chdir ("/") < 0) { if (Posix.chdir ("/") < 0) {
Posix.exit (Posix.EXIT_FAILURE); Posix.exit (Posix.EXIT_FAILURE);
} }
} }
Process.signal (ProcessSignal.INT, on_exit); Process.signal (ProcessSignal.INT, on_exit);
Process.signal (ProcessSignal.TERM, on_exit); Process.signal (ProcessSignal.TERM, on_exit);
Bus.own_name (BusType.SYSTEM, Bus.own_name (BusType.SYSTEM,
"org.tuf.manager.server", "org.tuf.manager.server",
BusNameOwnerFlags.NONE, BusNameOwnerFlags.NONE,
on_bus_acquired, on_bus_acquired,
() => {}, () => {},
() => { () => {
stderr.printf (_ ("Could not acquire bus name\n")); stderr.printf (_ ("Could not acquire bus name\n"));
}); });
loop = new MainLoop (); loop = new MainLoop ();
loop.run (); loop.run ();
return 0; return 0;
} }
} }
} }

983
src/server.vala
View File

File diff suppressed because it is too large Load Diff