← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kdevplatform/utopic-proposed

« back to all changes in this revision

Viewing changes to util/kdevplatform_shell_environment.sh

  • Committer: Package Import Robot
  • Author(s): Scarlett Clark
  • Date: 2014-08-30 03:52:11 UTC
  • mfrom: (0.3.26)
  • Revision ID: package-import@ubuntu.com-20140830035211-wndqlc843eu2v8nk
Tags: 1.7.0-0ubuntu1
* New upstream release
* Add XS-Testsuite: autopkgtest

Show diffs side-by-side

added added

removed removed

Lines of Context:
util/kdevplatform_shell_environment.sh
1
 
#!/bin/bash
 
1
#!/bin/sh
2
2
 
3
3
# This file is part of KDevelop
4
4
# Copyright 2011 David Nolden <david.nolden.kdevelop@art-master.de>
18
18
# the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19
19
# Boston, MA 02110-1301, USA.
20
20
 
21
 
if [ -e ~/.bashrc ]; then
22
 
    # Since this runs as a replacement for the init-file, we need to chain in the 'real' bash-rc
23
 
    source ~/.bashrc
 
21
# NOTE: While this script is more or less portable, it uses exclamation
 
22
# mark in function names, which goes beyond the SUS/POSIX specs. This is
 
23
# known to break with dash (Debian shell) at least.
 
24
 
 
25
if [ -n "$KDEV_REAL_ENV" ]; then
 
26
    # Since this runs as a replacement for the init-file, we need to chain in the 'real' one
 
27
    . "$KDEV_REAL_ENV"
24
28
fi
25
29
 
26
 
if ! [ "$APPLICATION_HOST" ]; then
 
30
if [ -z "$APPLICATION_HOST" ]; then
27
31
    export APPLICATION_HOST=$(hostname)
28
32
fi
29
33
 
30
 
if ! [ "$KDEV_SHELL_ENVIRONMENT_ID" ]; then
 
34
if [ -z "$KDEV_SHELL_ENVIRONMENT_ID" ]; then
31
35
    export KDEV_SHELL_ENVIRONMENT_ID="default"
32
36
fi
33
37
 
34
 
if ! [ "$KDEV_DBUS_ID" ]; then
 
38
if [ -z "$KDEV_DBUS_ID" ]; then
35
39
    echo "The required environment variable KDEV_DBUS_ID is not set. This variable defines the dbus id of the application instance instance which is supposed to be attached."
36
40
    exit 5
37
41
fi
47
51
fi
48
52
 
49
53
# Takes a list of tools, and prints a warning of one of them is not available in the path
50
 
function checkToolsInPath {
51
 
    for TOOL in $@; do
52
 
        if ! [ "$(which $TOOL 2> /dev/null)" ]; then
 
54
checkToolsInPath() {
 
55
    for TOOL in "$@"; do
 
56
        if [ -z "$(command -v $TOOL 2> /dev/null)" ]; then
53
57
            echo "The utility $TOOL is not in your path, the shell integration will not work properly."
54
58
        fi
55
59
    done
58
62
# Check if all required tools are there (on the host machine)
59
63
checkToolsInPath sed qdbus ls cut dirname mktemp basename readlink hostname
60
64
 
61
 
if ! [ "$KDEV_SSH_FORWARD_CHAIN" ]; then
 
65
if [ -n "$KDEV_SSH_FORWARD_CHAIN" ]; then
62
66
    # Check for additional utilities that are required on the client machine
63
67
    checkToolsInPath kioclient
64
68
fi
65
69
 
66
70
# Queries the session name from the running application instance
67
 
function getSessionName {
68
 
    echo "$(qdbus $KDEV_DBUS_ID /kdevelop/SessionController org.kdevelop.kdevelop.KDevelop.SessionController.sessionName)"
69
 
}
70
 
 
71
 
function getSessionDir {
72
 
    echo "$(qdbus $KDEV_DBUS_ID /kdevelop/SessionController org.kdevelop.kdevelop.KDevelop.SessionController.sessionDir)"
73
 
}
74
 
 
75
 
function getCurrentShellEnvPath {
76
 
    local ENV_ID=$KDEV_SHELL_ENVIRONMENT_ID
77
 
    if [ "$1" ]; then
78
 
        ENV_ID=$1
 
71
getSessionName() {
 
72
    qdbus "$KDEV_DBUS_ID" /kdevelop/SessionController org.kdevelop.kdevelop.KDevelop.SessionController.sessionName
 
73
}
 
74
 
 
75
getSessionDir() {
 
76
    qdbus "$KDEV_DBUS_ID" /kdevelop/SessionController org.kdevelop.kdevelop.KDevelop.SessionController.sessionDir
 
77
}
 
78
 
 
79
getCurrentShellEnvPath() {
 
80
    local ENV_ID="$KDEV_SHELL_ENVIRONMENT_ID"
 
81
    if [ -n "$1" ]; then
 
82
        ENV_ID="$1"
79
83
    fi
80
84
 
81
85
    echo "$(getSessionDir)/${ENV_ID}.sh"
82
86
}
83
87
 
84
 
function help! {
 
88
help! () {
85
89
    echo "You are controlling the $APPLICATION session '$(getSessionName)'"
86
90
    echo ""
87
 
    if [ "$1" == "" ]; then
 
91
    if [ "X$1" = X ]; then
88
92
    echo "Standard commands:"
89
93
    echo "raise!                                 - Raise the window."
90
94
    echo "sync!                                  - Synchronize the working directory with the currently open document. See \"help! sync\""
104
108
    echo "Most commands can be abbreviated by the first character(s), eg. r! instead of raise!, and se! instead of search!."
105
109
    fi
106
110
 
107
 
    if [ "$1" == "open" ]; then
 
111
    if [ X"$1" = "Xopen" ]; then
108
112
    echo "Extended opening:"
109
113
    echo "The open! command can also be used to open files in specific tool-view configurations, by adding split-separators:"
110
114
    echo "- Files around the / separator will be arranged horizontally by split-view."
123
127
    echo "Short forms: o! = open!, eo! = eopen!, c! = create!"
124
128
    fi
125
129
 
126
 
    if [ "$1" == "sync" ]; then
 
130
    if [ "X$1" = "Xsync" ]; then
127
131
    echo "Extended syncing:"
128
132
    echo "sync!    [[project-name]]           - If no project-name is given, then the sync! command synchronizes to the currently active document."
129
133
    echo "                                      If no document is active, then it synchronizes to the currently selected item in the project tree-view."
137
141
    echo "Short forms: s! = sync!, ss! = syncsel!, p! = project!, b! = bdir!"
138
142
    fi
139
143
 
140
 
    if [ "$1" == "remote" ]; then
 
144
    if [ "X$1" = "Xremote" ]; then
141
145
    echo "Extended remote commands:"
142
146
    echo "ssh!  [ssh arguments]                  - Connect to a remote host via ssh, keeping the control-connection alive."
143
147
    echo "                                       - The whole dbus environment is forwarded, KDevelop needs to be installed on both sides."
152
156
    echo "Short forms: e! = exec!, ce! = cexec!, cth! = copytohost!, ctc! = copytoclient!"
153
157
    fi
154
158
 
155
 
    if [ "$1" == "env" ]; then
 
159
    if [ "X$1" = "Xenv" ]; then
156
160
      echo "Environment management:"
157
161
      echo "The environment can be used to store session-specific macros and generally manipulate the shell environment"
158
162
      echo "for embedded shell sessions. The environment is sourced into the shell when the shell is initialized, and"
170
174
 
171
175
# Short versions of the commands:
172
176
 
173
 
function r! {
174
 
    raise! $@
175
 
}
176
 
 
177
 
function s! {
178
 
    sync! $@
179
 
}
180
 
 
181
 
function ss! {
182
 
    syncsel!
183
 
}
184
 
 
185
 
function syncsel! {
186
 
    sync! '[selection]'
187
 
}
188
 
 
189
 
function p! {
190
 
    if [ "$@" ]; then
191
 
        s! $@
192
 
    fi
193
 
    project!
194
 
}
195
 
 
196
 
function b! {
197
 
    if [ "$@" ]; then
198
 
        s! $@
199
 
    fi
200
 
    bdir!
201
 
}
202
 
 
203
 
function o! {
204
 
    open! $@
205
 
}
206
 
 
207
 
function eo! {
208
 
    eopen! $@
209
 
}
210
 
 
211
 
function e! {
212
 
    exec! $@
213
 
}
214
 
 
215
 
function ce! {
216
 
    cexec! $@
217
 
}
218
 
 
219
 
function c! {
220
 
    create! $@
221
 
}
222
 
 
223
 
function se! {
224
 
    search! $@
225
 
}
226
 
 
227
 
function ds! {
228
 
    dsearch! $@
229
 
}
230
 
 
231
 
function h! {
232
 
    help! $@
233
 
}
234
 
 
235
 
function cth! {
236
 
    copytohost! $@
237
 
}
238
 
 
239
 
function ctc! {
240
 
    copytoclient! $@
241
 
}
242
 
 
243
 
function sev! {
244
 
    setenv! $@
245
 
}
246
 
 
247
 
function ee! {
248
 
    editenv! $@
249
 
}
250
 
 
251
 
function shev! {
252
 
    showenv! $@
 
177
r! () {
 
178
    "raise!" "$@"
 
179
}
 
180
 
 
181
s! () {
 
182
    "sync!" "$@"
 
183
}
 
184
 
 
185
ss! () {
 
186
    "syncsel!"
 
187
}
 
188
 
 
189
syncsel! () {
 
190
    "sync!" '[selection]'
 
191
}
 
192
 
 
193
p! () {
 
194
    if [ $# -gt 0 ]; then
 
195
        "s!" "$@"
 
196
    fi
 
197
    "project!"
 
198
}
 
199
 
 
200
b! () {
 
201
    if [ $# -gt 0 ]; then
 
202
        "s!" "$@"
 
203
    fi
 
204
    "bdir!"
 
205
}
 
206
 
 
207
o! () {
 
208
    "open!" "$@"
 
209
}
 
210
 
 
211
eo! () {
 
212
    "eopen!" "$@"
 
213
}
 
214
 
 
215
e! () {
 
216
    "exec!" "$@"
 
217
}
 
218
 
 
219
ce! () {
 
220
    "cexec!" "$@"
 
221
}
 
222
 
 
223
c! () {
 
224
    "create!" "$@"
 
225
}
 
226
 
 
227
se! () {
 
228
    "search!" "$@"
 
229
}
 
230
 
 
231
ds! () {
 
232
    "dsearch!" "$@"
 
233
}
 
234
 
 
235
h! () {
 
236
    "help!" "$@"
 
237
}
 
238
 
 
239
cth! () {
 
240
    "copytohost!" "$@"
 
241
}
 
242
 
 
243
ctc! () {
 
244
    "copytoclient!" "$@"
 
245
}
 
246
 
 
247
sev! () {
 
248
    "setenv!" "$@"
 
249
}
 
250
 
 
251
ee! () {
 
252
    "editenv!" "$@"
 
253
}
 
254
 
 
255
shev! () {
 
256
    "showenv!" "$@"
253
257
}
254
258
 
255
259
# Internals:
256
260
 
257
261
# Opens a document in internally in the application
258
 
function openDocument {
 
262
openDocument () {
259
263
    RESULT=$(qdbus $KDEV_DBUS_ID /org/kdevelop/DocumentController org.kdevelop.DocumentController.openDocumentSimple $1)
260
 
    if ! [ "$RESULT" == "true" ]; then
 
264
    if ! [ "X$RESULT" == "Xtrue" ]; then
261
265
        echo "Failed to open $1"
262
266
    fi
263
267
}
264
268
 
265
269
# Opens a document in internally in the application
266
 
function openDocuments {
 
270
openDocuments () {
267
271
    RESULT=$(qdbus $KDEV_DBUS_ID /org/kdevelop/DocumentController org.kdevelop.DocumentController.openDocumentsSimple "(" $1 ")")
268
 
    if ! [ "$RESULT" == "true" ]; then
 
272
    if ! [ "X$RESULT" == "Xtrue" ]; then
269
273
        echo "Failed to open $1"
270
274
    fi
271
275
}
272
276
 
273
277
# Executes a command on the client machine using the custom-script integration.
274
278
# First argument: The full command. Second argument: The working directory.
275
 
function executeInApp {
 
279
executeInApp () {
276
280
    local CMD="$1"
277
281
    local WD=$2
278
 
    if ! [ "$WD" ]; then
 
282
    if [ -z "$WD" ]; then
279
283
        WD=$(pwd)
280
284
    fi
281
285
    RESULT=$(qdbus $KDEV_DBUS_ID /org/kdevelop/ExternalScriptPlugin org.kdevelop.ExternalScriptPlugin.executeCommand "$CMD" "$WD")
282
 
    if ! [ "$RESULT" == "true" ]; then
 
286
    if [ "X$RESULT" == "Xtrue" ]; then
283
287
        echo "Execution failed"
284
288
    fi
285
289
}
286
290
 
287
291
# First argument: The full command. Second argument: The working directory.
288
292
# Executes the command silently and synchronously, and returns the output
289
 
function executeInAppSync {
 
293
executeInAppSync () {
290
294
    local CMD=$1
291
295
    local WD=$2
292
 
    if ! [ "$WD" ]; then
 
296
    if [ -z "$WD" ]; then
293
297
        WD=$(pwd)
294
298
    fi
295
299
    RESULT=$(qdbus $KDEV_DBUS_ID /org/kdevelop/ExternalScriptPlugin org.kdevelop.ExternalScriptPlugin.executeCommandSync "$CMD" "$WD")
298
302
 
299
303
# Getter functions:
300
304
 
301
 
function getActiveDocument {
302
 
    qdbus $KDEV_DBUS_ID /org/kdevelop/DocumentController org.kdevelop.DocumentController.activeDocumentPath $@
303
 
}
304
 
 
305
 
function getOpenDocuments {
306
 
    qdbus $KDEV_DBUS_ID /org/kdevelop/DocumentController org.kdevelop.DocumentController.activeDocumentPaths
307
 
}
308
 
 
309
 
function raise! {
310
 
    qdbus $KDEV_DBUS_ID /kdevelop/MainWindow org.kdevelop.MainWindow.ensureVisible
311
 
}
312
 
 
313
 
function bdir! {
314
 
    TARG=$(qdbus $KDEV_DBUS_ID /org/kdevelop/ProjectController org.kdevelop.ProjectController.mapSourceBuild "$(pwd)" false)
315
 
    if [ "$TARG" ]; then
316
 
        cd $TARG
 
305
getActiveDocument () {
 
306
    qdbus "$KDEV_DBUS_ID" /org/kdevelop/DocumentController org.kdevelop.DocumentController.activeDocumentPath "$@"
 
307
}
 
308
 
 
309
getOpenDocuments () {
 
310
    qdbus "$KDEV_DBUS_ID" /org/kdevelop/DocumentController org.kdevelop.DocumentController.activeDocumentPaths
 
311
}
 
312
 
 
313
raise! () {
 
314
    qdbus "$KDEV_DBUS_ID" /kdevelop/MainWindow org.kdevelop.MainWindow.ensureVisible
 
315
}
 
316
 
 
317
bdir! () {
 
318
    TARG=$(qdbus "$KDEV_DBUS_ID" /org/kdevelop/ProjectController org.kdevelop.ProjectController.mapSourceBuild "$(pwd)" false)
 
319
    if [ -n "$TARG" ]; then
 
320
        cd -- "$TARG"
317
321
    else
318
322
        echo "Got no path"
319
323
    fi
320
324
}
321
325
 
322
 
function project! {
323
 
    TARG=$(qdbus $KDEV_DBUS_ID /org/kdevelop/ProjectController org.kdevelop.ProjectController.mapSourceBuild "$(pwd)" true)
324
 
    if [ "$TARG" ]; then
325
 
        cd $TARG
 
326
project! () {
 
327
    TARG=$(qdbus "$KDEV_DBUS_ID" /org/kdevelop/ProjectController org.kdevelop.ProjectController.mapSourceBuild "$(pwd)" true)
 
328
    if [ -n "$TARG" ]; then
 
329
        cd -- "$TARG"
326
330
    else
327
331
        echo "Got no path"
328
332
    fi
331
335
 
332
336
# Main functions:
333
337
 
334
 
function raise! {
335
 
    qdbus $KDEV_DBUS_ID /kdevelop/MainWindow org.kdevelop.MainWindow.ensureVisible
 
338
raise!() {
 
339
    qdbus "$KDEV_DBUS_ID" /kdevelop/MainWindow org.kdevelop.MainWindow.ensureVisible
336
340
}
337
341
 
338
 
function sync! {
 
342
sync!() {
339
343
    local P=$(getActiveDocument $@)
340
 
    if [ "$P" ]; then
 
344
    if [ -n "$P" ]; then
341
345
 
342
 
        if [[ "$P" == fish://* ]]; then
 
346
        case $P in
 
347
        fish://*)
343
348
            # This regular expression filters the user@host:port out of fish:///user@host:port/path/...
344
349
            LOGIN=$(echo $P | sed "s/fish\:\/\/*\([^\/]*\)\(\/.*\)/\1/")
345
350
            P_ON_HOST=$(echo $P | sed "s/fish\:\/\/*\([^\/]*\)\(\/.*\)/\2/")
370
375
                    return
371
376
                fi
372
377
            fi
373
 
 
374
 
        elif [ "$KDEV_SSH_FORWARD_CHAIN" ]; then
375
 
            # This session is being forwarded to another machine, but the current document is not
376
 
            # However, we won't complain, because it's possible that the machines share the same file-system
377
 
            if [ $(isEqualFileOnHostAndClient $P) != "yes" ]; then
378
 
                echo "Cannot synchronize the working directory, because the file systems do not match"
379
 
                return
 
378
            ;;
 
379
        *)
 
380
            if [ "$KDEV_SSH_FORWARD_CHAIN" ]; then
 
381
                # This session is being forwarded to another machine, but the current document is not
 
382
                # However, we won't complain, because it's possible that the machines share the same file-system
 
383
                if [ $(isEqualFileOnHostAndClient $P) != "yes" ]; then
 
384
                    echo "Cannot synchronize the working directory, because the file systems do not match"
 
385
                    return
 
386
                fi
380
387
            fi
381
 
        fi
 
388
            ;;
 
389
        esac
382
390
 
383
391
        [ -d "$P" ] || P=$(dirname "$P")
384
 
        cd "$P"
 
392
        cd -- "$P"
385
393
    else
386
394
        echo "Got no path"
387
395
    fi
389
397
 
390
398
# Take a path, and returns "yes" if the equal file is available on the host and the client
391
399
# The check is performed by comparing inode-numbers
392
 
function isEqualFileOnHostAndClient {
393
 
    function trimWhiteSpace() {
394
 
        echo $1
 
400
isEqualFileOnHostAndClient() {
 
401
    trimWhiteSpace() {
 
402
        printf "%s" "$1"
395
403
    }
396
404
 
397
405
    FILE=$1
398
 
    INODE_HOST=$(trimWhiteSpace $(ls --color=never -i $FILE | cut -d' ' -f1))
399
 
    INODE_CLIENT=$(trimWhiteSpace $(executeInAppSync "ls --color=never -i $FILE | cut -d' ' -f1" "$(dirname $FILE)"))
 
406
    INODE_HOST=$(trimWhiteSpace $(/bin/ls -i "$FILE" | cut -d' ' -f1) )
 
407
    INODE_CLIENT=$(trimWhiteSpace $(executeInAppSync "/bin/ls -i $FILE | cut -d' ' -f1" "$(dirname "$FILE")"))
400
408
    if [ "$INODE_HOST" == "$INODE_CLIENT" ]; then
401
409
        echo "yes"
402
410
    else
405
413
}
406
414
 
407
415
# Takes a relative file, returns an absolute file/url that should be valid on the client.
408
 
function mapFileToClient {
 
416
mapFileToClient() {
409
417
    local RELATIVE_FILE=$1
410
 
    FILE=$(readlink -f $RELATIVE_FILE)
 
418
    FILE=$(readlink -f "$RELATIVE_FILE")
411
419
    if ! [ -e "$FILE" ]; then
412
420
        # Try opening the file anyway, it might be an url or something else we don't understand here
413
421
        FILE=$RELATIVE_FILE
419
427
            if [ "$(isEqualFileOnHostAndClient "$FILE")" != "yes" ]; then
420
428
                    # We can eventually map the file using the fish protocol
421
429
                    FISH_HOST=$KDEV_SSH_FORWARD_CHAIN
422
 
                    if [[ "$FISH_HOST" == *\,* ]]; then
 
430
                    case $FISH_HOST in
 
431
                    *\,*)
423
432
                        # Extracts everything before the first comma
424
433
                        FISH_HOST=$(echo $FISH_HOST | sed 's/\([^,]*\),\(.*\)/\1/')
425
434
                        echo "ssh chain is too long: $KDEV_SSH_FORWARD_CHAIN mapping anyway using $FISH_HOST" 1>&2
426
 
                    fi
 
435
                        ;;
 
436
                    esac
427
437
                    # Theoretically, we can only map through fish if the forward-chains contains no comma, which means that
428
438
                    # we forward only once. Try anyway, there might be the same filesystem on the whole forward-chain.
429
439
                    FILE="fish://$FISH_HOST$FILE"
433
443
    echo $FILE
434
444
}
435
445
 
436
 
function open! {
 
446
open!() {
 
447
    # would break on files with whitespace in names
437
448
    FILES=$@
438
449
    NEWFILES=""
439
450
    for RELATIVE_FILE in $FILES; do
448
459
    openDocuments "$NEWFILES"
449
460
}
450
461
 
451
 
function eopen! {
 
462
eopen!() {
 
463
    # would break on files with whitespace in names
452
464
    FILES=$@
453
465
    for RELATIVE_FILE in $FILES; do
454
466
        FILE=$(mapFileToClient $RELATIVE_FILE)
456
468
    done
457
469
}
458
470
 
459
 
function exec! {
 
471
exec!() {
 
472
    # would break on files with whitespace in names
460
473
    FILES=$@
461
474
    ARGS=""
462
475
    for RELATIVE_FILE in $FILES; do
472
485
    executeInApp "$ARGS"
473
486
}
474
487
 
475
 
function copytohost! {
 
488
copytohost!() {
476
489
    executeInApp "kioclient copy $1 $(mapFileToClient $2)"
477
490
}
478
491
 
479
 
function copytoclient! {
 
492
copytoclient!() {
480
493
    executeInApp "kioclient copy $(mapFileToClient $1) $2"
481
494
}
482
495
 
483
 
function cexec! {
 
496
cexec!() {
 
497
    # would break on files with whitespace in names
484
498
    FILES=$@
485
499
    ARGS=""
486
500
    PREFIX=""
508
522
    executeInApp "$PREFIX $ARGS"
509
523
}
510
524
 
511
 
function create! {
512
 
    FILE=$(readlink -f $1)
513
 
    if ! [ "$FILE" ]; then
 
525
create!() {
 
526
    FILE=$(readlink -f "$1")
 
527
    if [ -z "$FILE" ]; then
514
528
        echo "Error: Bad arguments."
515
529
        return 1
516
530
    fi
518
532
        echo "The file $FILE already exists"
519
533
        return 2
520
534
    fi
521
 
    echo $2 > $FILE
 
535
    echo "$2" > $FILE
522
536
 
523
537
    openDocument $(mapFileToClient $FILE)
524
538
}
525
539
 
526
 
function search! {
 
540
search!() {
527
541
    PATTERN=$1
528
542
 
529
543
#     if ! [ "$PATTERN" ]; then
533
547
 
534
548
    LOCATION=$2
535
549
 
536
 
    if ! [ "$LOCATION" ]; then
 
550
    if [ -z "$LOCATION" ]; then
537
551
        LOCATION="."
538
552
    fi
539
553
 
540
 
    LOCATION=$(mapFileToClient $LOCATION)
 
554
    LOCATION=$(mapFileToClient "$LOCATION")
541
555
 
542
 
    for LOC in $*; do
543
 
        if [ "$LOC" == "$1" ]; then
544
 
            continue;
545
 
        fi
546
 
        if [ "$LOC" == "$2" ]; then
547
 
            continue;
548
 
        fi
549
 
        LOCATION="$LOCATION;$(mapFileToClient $LOC)"
 
556
    for LOC in "$@"; do
 
557
        if [ "X$LOC" == "X$1" ]; then
 
558
            continue;
 
559
        fi
 
560
        if [ "X$LOC" == "X$2" ]; then
 
561
            continue;
 
562
        fi
 
563
        LOCATION="$LOCATION;$(mapFileToClient "$LOC")"
550
564
    done
551
565
 
552
 
    qdbus $KDEV_DBUS_ID /org/kdevelop/GrepViewPlugin org.kdevelop.kdevelop.GrepViewPlugin.startSearch "$PATTERN" "$LOCATION" true
 
566
    qdbus "$KDEV_DBUS_ID" /org/kdevelop/GrepViewPlugin org.kdevelop.kdevelop.GrepViewPlugin.startSearch "$PATTERN" "$LOCATION" true
553
567
}
554
568
 
555
 
function dsearch! {
 
569
dsearch!() {
556
570
    PATTERN=$1
557
571
 
558
572
    if ! [ "$PATTERN" ]; then
566
580
        LOCATION="."
567
581
    fi
568
582
 
569
 
    LOCATION=$(mapFileToClient $LOCATION)
 
583
    LOCATION=$(mapFileToClient "$LOCATION")
570
584
 
571
 
    for LOC in $*; do
572
 
        if [ "$LOC" == "$1" ]; then
573
 
            continue;
574
 
        fi
575
 
        if [ "$LOC" == "$2" ]; then
576
 
            continue;
577
 
        fi
578
 
        LOCATION="$LOCATION;$(mapFileToClient $LOC)"
 
585
    for LOC in "$@"; do
 
586
        if [ "X$LOC" == "X$1" ]; then
 
587
            continue;
 
588
        fi
 
589
        if [ "X$LOC" == "X$2" ]; then
 
590
            continue;
 
591
        fi
 
592
        LOCATION="$LOCATION;$(mapFileToClient "$LOC")"
579
593
    done
580
594
 
581
 
    qdbus $KDEV_DBUS_ID /org/kdevelop/GrepViewPlugin org.kdevelop.kdevelop.GrepViewPlugin.startSearch "$PATTERN" "$LOCATION" false
 
595
    qdbus "$KDEV_DBUS_ID" /org/kdevelop/GrepViewPlugin org.kdevelop.kdevelop.GrepViewPlugin.startSearch "$PATTERN" "$LOCATION" false
582
596
}
583
597
 
584
598
##### SSH DBUS FORWARDING --------------------------------------------------------------------------------------------------------------------
596
610
export DBUS_ABSTRACT_SOCKET_TARGET_INDEX=1
597
611
export DBUS_ABSTRACT_SOCKET_MAX_TARGET_INDEX=1000
598
612
 
599
 
function getPortFromSSHCommand {
 
613
getPortFromSSHCommand() {
600
614
    # The port is given to ssh exclusively in the format "-p PORT"
601
615
    # This regular expression extracts the "4821" from "ssh -q bla1 -p 4821 bla2"
602
616
    local ARGS=$@
603
617
    local RET=$(echo "$@" | sed "s/.*-p \+\([0-9]*\).*/\1/")
604
 
    if [ "$ARGS" == "$RET" ]; then
 
618
    if [ "X$ARGS" == "X$RET" ]; then
605
619
        # There was no match
606
620
        echo ""
607
621
    else
609
623
    fi
610
624
}
611
625
 
612
 
function getLoginFromSSHCommand {
 
626
getLoginFromSSHCommand() {
613
627
    # The login name can be given to ssh in the format "-l NAME"
614
628
    # This regular expression extracts the "NAME" from "ssh -q bla1 -l NAME bla2"
615
629
    local ARGS=$@
616
630
    local RET=$(echo "$ARGS" | sed "s/.*-l \+\([a-z,A-Z,_,0-9]*\).*/\1/")
617
 
    if [ "$RET" == "$ARGS" ] || [ "$RET" == "" ]; then
 
631
    if [ "X$RET" == "X$ARGS" -o -z "$RET" ]; then
618
632
        # There was no match
619
633
        echo ""
620
634
    else
622
636
    fi
623
637
}
624
638
 
625
 
function getHostFromSSHCommand {
 
639
getHostFromSSHCommand() {
626
640
    # This regular expression extracts the "bla2" from "echo "ssh -q bla1 -p 4821 bla2"
627
641
    # Specifically, it finds the first argument which is not preceded by a "-x" parameter kind specification.
 
642
    # XXX This will break if you'd call, say, "ssh -v host ..."
628
643
 
629
644
    local CLEANED=""
630
645
    local NEWCLEANED="$@"
631
646
 
632
 
    while ! [ "$NEWCLEANED" == "$CLEANED" ]; do
 
647
    while ! [ "X$NEWCLEANED" == "X$CLEANED" ]; do
633
648
        CLEANED="$NEWCLEANED"
634
649
    # This expression removes one "-x ARG" parameter
635
 
        NEWCLEANED="$(echo $CLEANED | sed "s/\(.*\)\(-[a-z,A-Z] \+[a-z,0-9]*\)\ \(.*\)/\1\3/")"
 
650
        NEWCLEANED="$(echo "$CLEANED" | sed "s/\(.*\)\(-[a-z,A-Z] \+[a-z,0-9]*\)\ \(.*\)/\1\3/")"
636
651
    done
637
652
 
638
653
    # After cleaning, the result should only consist of the host-name followed by an optional command.
639
654
    # Select the host-name, by extracting the forst column.
640
 
    echo $CLEANED | cut --delimiter=" " -f 1
 
655
    echo "$CLEANED" | cut -d" " -f 1
641
656
}
642
657
 
643
 
function getSSHForwardOptionsFromCommand {
 
658
getSSHForwardOptionsFromCommand() {
644
659
 
645
660
    HOST="$(getLoginFromSSHCommand "$@")$(getHostFromSSHCommand "$@")$(getPortFromSSHCommand "$@")"
646
661
 
653
668
    fi
654
669
}
655
670
 
656
 
function getDBusAbstractSocketSuffix {
 
671
getDBusAbstractSocketSuffix() {
657
672
    # From something like DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-wYmSkVH7FE,guid=b214dad39e0292a4299778d64d761a5b
658
673
    # extract the /tmp/dbus-wYmSkVH7FE
659
674
    echo $DBUS_SESSION_BUS_ADDRESS | sed 's/unix\:abstract\=.*\(,guid\=.*\)/\1/'
660
675
}
661
676
 
662
 
function keepForwardingDBusToTCPSocket {
 
677
keepForwardingDBusToTCPSocket() {
663
678
    while ! $KDEV_BASEDIR/kdev_dbus_socket_transformer $DBUS_FORWARDING_TCP_LOCAL_PORT --bind-only; do
664
679
        if (($DBUS_FORWARDING_TCP_LOCAL_PORT<$DBUS_FORWARDING_TCP_MAX_LOCAL_PORT)); then
665
680
            export DBUS_FORWARDING_TCP_LOCAL_PORT=$(($DBUS_FORWARDING_TCP_LOCAL_PORT+1))
674
689
    return 0;
675
690
}
676
691
 
677
 
function keepForwardingDBusFromTCPSocket {
 
692
keepForwardingDBusFromTCPSocket() {
678
693
 
679
694
    while ! $KDEV_BASEDIR/kdev_dbus_socket_transformer $FORWARD_DBUS_FROM_PORT ${DBUS_ABSTRACT_SOCKET_TARGET_BASE_PATH}-${DBUS_ABSTRACT_SOCKET_TARGET_INDEX} --bind-only; do
680
695
        if ((${DBUS_ABSTRACT_SOCKET_TARGET_INDEX}<${DBUS_ABSTRACT_SOCKET_MAX_TARGET_INDEX})); then
690
705
    $KDEV_BASEDIR/kdev_dbus_socket_transformer $FORWARD_DBUS_FROM_PORT $PATH&
691
706
}
692
707
 
693
 
function ssh! {
 
708
ssh! () {
 
709
    # XXX This entire function is broken by design
694
710
    keepForwardingDBusToTCPSocket # Start the dbus forwarding subprocess
695
711
    DBUS_FORWARDING_TCP_TARGET_PORT=$((5000+($RANDOM%50000)))
696
712
 
697
 
    ssh $@ -t -R localhost:$DBUS_FORWARDING_TCP_TARGET_PORT:localhost:$DBUS_FORWARDING_TCP_LOCAL_PORT \
 
713
    ssh "$@" -t -R localhost:$DBUS_FORWARDING_TCP_TARGET_PORT:localhost:$DBUS_FORWARDING_TCP_LOCAL_PORT \
698
714
         " APPLICATION=$APPLICATION \
699
715
           KDEV_BASEDIR=$KDEV_BASEDIR \
700
716
           KDEV_DBUS_ID=$KDEV_DBUS_ID \
726
742
}
727
743
 
728
744
# A version of ssh! that preserves the current working directory
729
 
function ssw! {
 
745
ssw! () {
730
746
    KDEV_WORKING_DIR=$(pwd)
731
 
    ssh! $@
 
747
    ssh! "$@"
732
748
}
733
749
 
734
 
function env! {
 
750
env! () {
735
751
    FILES="$(executeInAppSync "ls $(getSessionDir)/*.sh" "")"
736
752
    for FILE in $FILES; do
737
 
        FILE=$(basename $FILE)
 
753
        FILE=$(basename "$FILE")
738
754
        ID=${FILE%.sh} # This ugly construct strips away the .sh suffix
739
 
        if [ "$ID" == "$KDEV_SHELL_ENVIRONMENT_ID" ]; then
 
755
        if [ "X$ID" == "X$KDEV_SHELL_ENVIRONMENT_ID" ]; then
740
756
            echo "$ID   [current]"
741
757
        else
742
758
            echo "$ID"
744
760
    done
745
761
}
746
762
 
747
 
function editenv! {
 
763
editenv! () {
748
764
    local ENV_ID=$KDEV_SHELL_ENVIRONMENT_ID
749
765
    if [ "$1" ]; then
750
766
        ENV_ID=$1
755
771
    openDocument "$(getCurrentShellEnvPath $ENV_ID)"
756
772
}
757
773
 
758
 
function setenv! {
 
774
setenv! () {
759
775
    if [ "$1" ]; then
760
776
        KDEV_SHELL_ENVIRONMENT_ID=$1
761
777
    fi
773
789
    rm $TEMP
774
790
}
775
791
 
776
 
function showenv! {
 
792
showenv! () {
777
793
    local ENV_ID=$KDEV_SHELL_ENVIRONMENT_ID
778
 
    if [ "$1" ]; then
 
794
    if [ -n "$1" ]; then
779
795
        ENV_ID=$1
780
796
    fi
781
797
 
785
801
    echo $(executeInAppSync "cat \"$(getCurrentShellEnvPath $ENV_ID)\"" "")
786
802
}
787
803
 
788
 
if [ "$FORWARD_DBUS_FROM_PORT" ]; then
 
804
if [ -n "$FORWARD_DBUS_FROM_PORT" ]; then
789
805
    # Start the target-side dbus forwarding, transforming from the ssh pipe to the abstract unix domain socket
790
806
    export DBUS_SESSION_BUS_ADDRESS=unix:abstract=${DBUS_ABSTRACT_SOCKET_TARGET_BASE_PATH}-${DBUS_ABSTRACT_SOCKET_TARGET_INDEX}${DBUS_SOCKET_SUFFIX}
791
807
    keepForwardingDBusFromTCPSocket
792
808
fi
793
809
 
794
 
setenv!
 
810
"setenv!"
795
811
 
796
812
##### INITIALIZATION --------------------------------------------------------------------------------------------------------------------
797
813
 
800
816
 
801
817
echo "You are controlling the $APPLICATION session '$(getSessionName)'. Type help! for more information."
802
818
 
803
 
if [ "$KDEV_WORKING_DIR" ]; then
804
 
    cd $KDEV_WORKING_DIR
 
819
if [ -n "$KDEV_WORKING_DIR" ]; then
 
820
    cd -- "$KDEV_WORKING_DIR"
805
821
fi