Como trabalhar com processos?

Question

Eu tenho visto perguntas semelhantes aqui, mas não recebi minha resposta. Talvez seja porque eu sou novo em tudo isso e simplesmente não entendo. Eu quero que meu aplicativo funcione principalmente como um indicador. E se o usuário o iniciasse novamente, ele verificaria se já está em execução, se é então, fornecer todos os dados de entrada para esse processo e sair.

• Primeiro, preciso verificar se está em execução. Eu vi a resposta onde você pode fazer um arquivo de bruxa quando o programa é iniciado e, em seguida, verifique se ele existe ... Mas e se alguém iria apagá-lo? Não posso perguntar ao SO se existe um processo chamado "myApp" ou algo assim?
• A próxima coisa que eu realmente não entendo é como se comunicar com o processo. Como faço para dar os dados de entrada e o que eles vão fazer com isso? Funciona exatamente como iniciar um novo aplicativo, através do método main ()?

Estou tentando criar isso usando rapidamente. Então seria legal se você pudesse me dar alguns exemplos de python ou link para algo assim.

    

Answer 1

Descobri que realmente precisava que a DBus conseguisse o que eu precisava. Então, aqui está o que eu precisava fazer:

1. Verifique se meu serviço está no dbus
2. Se ele passar todas as variáveis de entrada para ele e sair
3. se não for criar meu serviço dbus e iniciar meu programa
   em Python, seria algo parecido com isto:

# using quickly...  
#     
#   __init__.py  
# # # # # # # # # # # # #  
import dbus  
import sys  
from gi.repository import Gtk  
# import whatever else you need...  

from my_app import MyAppDBusService
# import whatever else from your app...

def main():
    bus = dbus.SessionBus()

    # Check if my app is running and providing DBus service
    if bus.name_has_owner('com.example.myApp'):
        #if it is running pass the commandline variables to it and exit

        #get my service from DBus
        myService = bus.get_object('com.example.myApp', '/com/example/myApp')
        #get offered method from DBus
        myMethod = myService.get_dbus_method('my_method', 'com.example.myApp')
        #call the method and pass comandline varialbes
        myMethod(sys.argv)
        #exit
        sys.exit(0)
    else:
        #if not running
        #run my DBus service by creating MyAppDBusService instance
        MyAppDBusService.MyAppDBusService()

        #do whatever with sys.argv...
        #...

        Gtk.main()

# MyAppDBusService.py
# # # # # # # # # # # # # #

import dbus
import dbus.service
from dbus.mainloop.glib import DBusGMainLoop
#import whatever else you need...

# use the dbus mainloop
DBusGMainLoop(set_as_default = True)

class MyAppDBusService(dbus.service.Object):
    def __init__(self):
        # create dbus service in the SessionBus()
        dbus_name = dbus.service.BusName('com.example.myApp', bus=dbus.SessionBus())
        dbus.service.Object.__init__(self, dbus_name, '/com/example/myApp')

    # offer a method to call using my dbus service
    @dbus.service.method('com.example.myApp')
    def my_method(self, argv):
        #do whatever with argv...

    

Answer 2

Na verdade, existe um pacote chamado python-psutil para fornecer as informações do processo usando códigos python.

você pode obter o pacote aqui link

Existe mais um pacote útil chamado PSI

PSI é um pacote Python que fornece acesso em tempo real a processos e outras informações diversas do sistema, como arquitetura, boothime e sistemas de arquivos. Ele tem uma API pythonic que é consistente em todas as plataformas suportadas, mas também expõe detalhes específicos da plataforma quando desejável.

Mais informações aqui: link

mais um link: link