set pslst [exec ps -ef | grep mysingle.tcl]
  set cntr 0
  foreach i $pslst {
    if { $i == "tclsh" } {
      incr cntr
    }
  }
  if { $cntr == 1 } {
    puts "One instance of the script is running"
  } else {
    puts "$cntr instances of the script are running"
  }

set socketID 12345;  # Pick something
try {
    socket -server {apply {{ch args} {
        close $ch
        raise .
    }}} -myaddr localhost $socketID
} trap {POSIX EADDRINUSE} {} {
    close [socket localhost $socketID]
}

set socketID 12345;  # Pick something
catch {socket -server {
        apply {{ch args} {
                        close $ch
                        raise .
                        }
                }
        } -myaddr localhost $socketID } msg
        
if {$msg == "couldn't open socket: address already in use"} {
        close [socket localhost $socketID]
}

   set appPid [pid]
  
   proc init {} {
           global appPid
           set chck [send pk2gui checkInstance $appPid]
           if {$chck} {
                   exit
          } 
  }       
          
  proc checkInstance args {
          global appPid
          
          if {$args != $appPid} {
                  return 1
          } else {
                  return 0
          }
  }       
                  
  init  

if {[tk appname newName] != newName} {
  exit
}

if {[tk appname newName] != "newName"} {
  exit
}

##
# SelfService
#
# This package creates a mechanism for a script to figure out if it is already
# running, and still sane, by using sockets to pass messages to another copy of
# itself.  This is most useful for embedded system scripts which are invoked
# periodically by the operating system (i.e. systemd, cron, etc...).
#
# This only works in unix because the killOthers proc uses standard unix utils.

package provide SelfService 1.0

namespace eval selfservice {
    variable S
    array set S {
        Port {}
        Server {}
    }

    proc Server {chan addr port} {
        fconfigure $chan -blocking 0 -buffering none
        fileevent $chan readable [list selfservice::Reader $chan]
    }

    # Used for both query and response
    proc Reader {chan} {
        variable S

        set line [gets $chan]

        if {$line eq "STATUS"} {
            puts $chan "STATUS OK"
            flush $chan
        } elseif {$line eq "STATUS OK"} {
            set S(Response) $line
        }

        if {[eof $chan]} {
            catch {close $chan}
        }
    }

    # Setup server socket
    # port can be 0, in which case the system will pick an open port
    # In either case, S(Port) will refelct the actual opened port number
    proc startup {name port} {
        variable S
        killOthers $name

        set S(Server) [socket -server selfservice::Server $port]
        set S(Port) [lindex [fconfigure $S(Server) -sockname] 2]
        return $S(Server)
    }

    proc shutdown {} {
        variable S
        catch {close $S(Server)}
        return $S(Server)
    }

    # Get the current port number
    proc getPort {} {
        variable S
        return $S(Port)
    }

    # Returns bool 1 if server is up and sane, 0 otherwise
    proc isOk {port} {
        variable S
        if {[catch {socket localhost $port} chan]} {
            return 0
        }

        # Check to see if server is still sane
        fconfigure $chan -blocking 0 -buffering none
        fileevent $chan readable [list selfservice::Reader $chan]
        puts $chan "STATUS"
        flush $chan

        set S(Response) ""
        set afterId [after 5000 [list set selfservice::S(Response) "timeout"]]
        vwait selfservice::S(Response)

        # Shutdown channel
        after cancel $afterId
        catch {close $chan}

        if {$S(Response) eq "STATUS OK"} {
            return 1
        } else {
            return 0
        }
    }

    # Kills all processes which match name
    # Returns a list of the process ids which were killed
    proc killOthers {name} {
        # kill all processes that match pattern and are not my pid
        set ps [split [exec ps -eo pid,cmd | grep $name] "\n"]
        set ps [lrange $ps 0 end-1];     # Ignore the grep command itself
        set killList {}
        foreach p $ps {
            lappend killList [lindex $p 0]
        }
        set killList [lsearch -all -inline -not $killList [pid]]
        foreach pid $killList {
            catch {exec kill -9 $pid}
        }
        return $killList
    }
}

# Example usage
if {[selfservice::isOk 12345]} {
    puts "Server is OK, exiting"
    exit
} else {
    puts "No response from server"
}
puts "Starting new server..."
selfservice::startup $::argv0 12345
# rest of script here...

  # cat passwrap.sh
  !/bin/bash -f

   export POPID="BashInit$POPID"
   if [ ! $POPID == "BashInit" ]; then
     echo "$0 is already running..."
     exit 1
   fi
   # Run expect script to set shortcuts
   expect passout.exp

 #!/usr/bin/expect
 set SCRIPT [info script]
 if { [info exists ::env(PSTAT) ] } {
   puts "\n$SCRIPT is already running. Cannot restart in child process.\n"
   exit 1
 }
 set ::env(PSTAT) "Is running"

 set PPassword "L0ngP@ZZWurdThAt1cann0tTyp3wIthOutM@kingAsimpleMisteak"
 spawn /bin/bash
 interact {
    "~!Pp"   { send -- "$PPassword" }
    "~PID"   { send -- "$PID" }
    "~!!P"   { exec kill -9 $PID ;# annihilate this process }
    "~!!K"   { send -- "kill -9 $PID\r" ;# nuke it another way }
    "~psf"   { send -- "ps -ef | grep "; # find a string in ps listing }
    "~Gg"    { send -- "a random loooong command that I hate typing"; }
    "~Hh"    { send -- "Another long string that I want to shortcut"; }
    "~!JJJ"  { send -- "The Daily Planet: J Jonah Jameson" }
  }

• Home
• Recent changes
• Help
• WhoAmI/Logout
• Create new page
• Random page
• Previous page
• Next page
• 
  
• Add comments
• Edit
• History
• Edit summary
• References