def boot(path, gtk=False, gst=True, installReactor=True): # python 2.5 and twisted < 2.5 don't work together pythonMM = sys.version_info[0:2] from twisted.copyright import version twistedMM = tuple([int(n) for n in version.split('.')[0:2]]) if pythonMM >= (2, 5) and twistedMM < (2, 5): raise SystemError("Twisted versions older than 2.5.0 do not work with " "Python 2.5 and newer. " "Please upgrade Twisted or downgrade Python.") if gtk or gst: init_gobject() if gtk: init_kiwi() if gst: from flumotion.configure import configure configure.gst_version = init_gst() global USE_GTK, USE_GST USE_GTK = gtk USE_GST = gst init_option_parser(gtk, gst) # installing the reactor could override our packager's import hooks ... if installReactor: from twisted.internet import gtk2reactor try: gtk2reactor.install(useGtk=gtk) except RuntimeError, e: safeprintf(sys.stderr, 'ERROR: %s\n', e) sys.exit(1)
def activate(self, shell): from twisted.internet import gtk2reactor try: gtk2reactor.install() except AssertionError, e: # sometimes it's already installed print e
def client(): from twisted.internet import gtk2reactor gtk2reactor.install() from twisted.internet import reactor # import gobject # reactor.callWhenRunning(gobject.threads_init) # gobject.threads_init() options = ClientOptions() options.parseOptions() from afm.ui.app import Application app = Application(options) reactor.addSystemEventTrigger('before', 'shutdown', logging.getLogger(__name__).info, 'Stopping AFM Client') logging.getLogger(__name__).info("AFM Client Started") try: reactor.run() except KeyboardInterrupt: reactor.stop() except: raise from twisted.python import log log.err()
def activate(self, shell): from twisted.internet import gtk2reactor try: gtk2reactor.install() except AssertionError, e: # sometimes it's already installed self.warning("gtk2reactor already installed %r" % e)
def cptsoul(): # cmdline parser = ArgumentParser(prog='cptsoul') parser.add_argument('-v', '--verbose', action='count', dest='verbose', help='Set verbose mode', default=0) parser.add_argument('-t', action='store_true', dest='tray', help='Start in tray') parser.add_argument('-d', action='store_true', dest='debug', help='Start with debug window') CptCommon.cmdline = parser.parse_args() # imports from twisted.internet import gtk2reactor gtk2reactor.install() from twisted.internet import reactor from cptsoul.config import createConfigFile from cptsoul.manager import Manager # start configLogging() CptCommon.config = createConfigFile() manager = Manager() manager() reactor.run()
def install_reactor(): from twisted.internet import gtk2reactor from twisted.internet.error import ReactorAlreadyInstalledError try: # needed for glib.idle_add, and signals gtk2reactor.install() except ReactorAlreadyInstalledError: pass
def configure(factory): """Set the right reactor up and get the GUI going.""" from twisted.internet import gtk2reactor gtk2reactor.install() gui = GUI(factory.realm) macros = {from_string("<page up>"): gui.forward_page_up_cb, from_string('<page down>'): gui.forward_page_down_cb, from_string("C-c"): gui.maybe_forward_copy_cb} factory.realm.macros.update(macros) factory.realm.baked_in_macros.update(macros)
def main(): from twisted.internet import gtk2reactor try: gtk2reactor.install() except: pass from twisted.internet import reactor con = pynaoqi.getDefaultConnection() notes = NotesMain(con) notes._w.show_all() reactor.run()
def maybeInstallDBus(): import shtoom.dbus if shtoom.dbus.isAvailable(): try: from twisted.internet import glib2reactor glib2reactor.install() except: try: from twisted.internet import gtk2reactor gtk2reactor.install() except: shtoom.dbus._setUnavailable()
def installDbusReactor(): try: from twisted.internet import glib2reactor glib2reactor.install() return True except: try: from twisted.internet import gtk2reactor gtk2reactor.install() return True except: return False
def installDbusReactor(): try: from twisted.internet import glib2reactor glib2reactor.install() return True except: try: from twisted.internet import gtk2reactor gtk2reactor.install() return True except: return False
def installgtkreactor(): import pynaoqi options = pynaoqi.getDefaultOptions() using_gtk = False if options.twisted and not options.nogtk: # Try to throw in gtk support try: from twisted.internet import gtk2reactor gtk2reactor.install() using_gtk = True except AssertionError, e: using_gtk = True except:
def main(): """Launch the client. This is the main entry point. This will first initialise the GUI, then load the main module specified on the command line. """ options = parser.parse_args() if options.module_directory != "": directory = options.module_directory import sys sys.path.append(directory) if options.gui == 'gtk': from twisted.internet import gtk2reactor gtk2reactor.install() from twisted.internet import reactor modclass = load_file(options.modulename) factory = TelnetClientFactory(modclass.name, modclass.encoding, options.modulename, reactor) if options.gui == 'gtk': from pymudclient.gui.gtkgui import configure factory.realm.gui = ImperianGui(factory.realm) configure(factory) factory.realm.module_settings_dir=options.settings_directory modinstance = factory.realm.load_module(modclass) factory.realm.gmcp_handler = modinstance.gmcp_handler modinstance.is_main(factory.realm) from twisted.internet import reactor #pylint kicks up a major fuss about these lines, but that's because #Twisted does some hackery with the reactor namespace. #pylint: disable-msg=E1101 reactor.connectTCP(modclass.host, modclass.port, factory) if not options.profile: reactor.run() else: import cProfile cProfile.runctx("reactor.run()", globals(), locals(), filename = "pymudclient.prof")
def main(clazz=Joints): global con con = pynaoqi.getDefaultConnection(with_twisted=True) class Main(clazz): def _onDestroy(self, *args): super(Main, self)._onDestroy(*args) print "quitting.." reactor.stop() from twisted.internet import gtk2reactor try: gtk2reactor.install() except: pass window = Main(con) reactor.run()
def run_gtk2(config): from twisted.internet import gtk2reactor gtk2reactor.install() from twisted.spread.ui import gtk2util sys.argv[:] = ['manhole'] from twisted.manhole.ui import gtk2manhole o = config.opts defaults = { 'host': o['host'], 'port': o['port'], 'identityName': o['user'], 'password': o['password'], 'serviceName': o['service'], 'perspectiveName': o['perspective'] } w = gtk2manhole.ManholeWindow() w.setDefaults(defaults) w.login()
def main(argv): from mushin.common import log log.init() log.debug('maemo', 'main') from twisted.internet import gtk2reactor gtk2reactor.install() from twisted.internet import reactor # set paisley to non-strict since we only have simplejson on maemo from mushin.extern.paisley import pjson assert not pjson.STRICT log.logTwisted() reactor.callWhenRunning(start) reactor.run()
def main(): from twisted.internet import gtk2reactor reactor = gtk2reactor.install() from fbuploader.main_window import MainWindow log.info('Starting Main Window') main_window = MainWindow() main_window.show() reactor.run()
def main(application): import gnome global gnomeProgram gnomeProgram = gnome.init("Shtoom", "Whatever Version") from twisted.internet import gtk2reactor gtk2reactor.install() from shtoom.ui.gnomeui.main import ShtoomWindow UI = ShtoomWindow() UI.connectApplication(application) from shtoom import log if application.getPref('stdout'): import sys log.startLogging(sys.stdout, setStdout=False) else: log.startLogging(UI.getLogger(), setStdout=False) return UI
def main(application): import gnome global gnomeProgram gnomeProgram = gnome.init("Shtoom", "Whatever Version") from twisted.internet import gtk2reactor gtk2reactor.install() from shtoom.ui.gnomeui.main import ShtoomWindow UI = ShtoomWindow() UI.connectApplication(application) from shtoom import log if application.getPref('stdout'): import sys log.startLogging(sys.stdout, setStdout=False) else: log.startLogging(UI.getLogger(), setStdout=False) return UI
def run_gtk2(config): # Put these off until after we parse options, so we know what reactor # to load. from twisted.internet import gtk2reactor gtk2reactor.install() # Put this off until after we parse options, or else gnome eats them. sys.argv[:] = ['manhole'] from twisted.manhole.ui import gtk2manhole o = config.opts defaults = { 'host': o['host'], 'port': o['port'], 'identityName': o['user'], 'password': o['password'], 'serviceName': o['service'], 'perspectiveName': o['perspective'] } w = gtk2manhole.ManholeWindow() w.setDefaults(defaults) w.login()
def run_gtk2(config): # Put these off until after we parse options, so we know what reactor # to load. from twisted.internet import gtk2reactor gtk2reactor.install() # Put this off until after we parse options, or else gnome eats them. sys.argv[:] = ['manhole'] from twisted.manhole.ui import gtk2manhole o = config.opts defaults = { 'host': o['host'], 'port': o['port'], 'identityName': o['user'], 'password': o['password'], 'serviceName': o['service'], 'perspectiveName': o['perspective'] } w = gtk2manhole.ManholeWindow() w.setDefaults(defaults) w.login()
def main(argv, reactor=None): """Run the client GUI. Typical use: >>> sys.exit(main(sys.argv)) @param argv: The arguments to run it with, e.g. sys.argv. @param reactor: The reactor to use. Must be compatible with gtk as this module uses gtk API"s. @return exitcode: The exit code it returned, as per sys.exit. """ if reactor is None: from twisted.internet import gtk2reactor gtk2reactor.install() from twisted.internet import reactor try: AWSStatusIcon(reactor) gobject.set_application_name("aws-status") reactor.run() except ValueError: # In this case, the user cancelled, and the exception bubbled to here. pass
def run_gtk2(config): # Put these off until after we parse options, so we know what reactor # to load. from twisted.internet import gtk2reactor gtk2reactor.install() # Put this off until after we parse options, or else gnome eats them. sys.argv[:] = ["manhole"] from twisted.manhole.ui import gtk2manhole o = config.opts defaults = { "host": o["host"], "port": o["port"], "identityName": o["user"], "password": o["password"], "serviceName": o["service"], "perspectiveName": o["perspective"], } w = gtk2manhole.ManholeWindow() w.setDefaults(defaults) w.login()
def maybeInstallReactor(): import sys try: from twisted.internet import gtk3reactor # s/2/3 if you're using gtk3 reactor = gtk3reactor.install() reactor.startRunning() reactor._simulate() return reactor except: try: from twisted.internet import gtk2reactor reactor = gtk2reactor.install() reactor.startRunning() reactor._simulate() return reactor except: print "This plugin requires twisted to be installed" exit(-1)
def maybeInstallReactor(): import sys try: from twisted.internet import gtk3reactor # s/2/3 if you're using gtk3 reactor = gtk3reactor.install() reactor.startRunning() reactor._simulate() return reactor except: try: from twisted.internet import gtk2reactor reactor = gtk2reactor.install() reactor.startRunning() reactor._simulate() return reactor except: print "This plugin requires twisted to be installed" exit(-1)
def install(): """Start up the Twisted networking support. Returns the new, running reactor.""" #This works fine anyway I think? Not really sure why this is here, just keeping it how it was in Twisted if runtime.platform.getType() == 'posix': reactor = gtk2reactor.install(ProgramState.USE_GTK) #Windows needs this custom class else: try: reactor = GtkReactor() installReactor(reactor) except socket.error, e: #NOTE: 10022 is a bit suspect. I saw it once (it's "invalid argument"), #but it can apparently happen in cases that might be caused by a firewall... #10013 is "forbidden" #10047 is "cannot bind" #10049 is "Can't assign requested address" if e[0] not in (10013, 10047, 10049, 10022): raise e import win32api win32api.MessageBox(0, "You must allow incoming and outgoing connections for both BitBlinder.exe and Tor.exe in your firewall. Otherwise, BitBlinder will not work correctly.", "Firewalled") sys.exit(-5)
# Copyright (c) 2014 Sartaj Singh # Licensed under the MIT license. ## """ Development script To run without actually installing Picks up local changes """ # system imports import sys # twisted imports from twisted.internet import gtk2reactor gtk2reactor.install() # install reactor for gui from twisted.internet import reactor # Other imports import main from client import options if __name__ == '__main__': args = options.parse_args() # parse the arguments addresses = [] client = args.client host, port, server = args.iface, args.port, args.server if host != None: addresses.append((host, port, server)) try:
def install_gtk2(app): # not tested del sys.modules['twisted.internet.reactor'] from twisted.internet import gtk2reactor gtk2reactor.install() from twisted.internet import reactor
def run(): """ Runs the application. """ parser = OptionParser(usage="%prog [config file] [options]", version="%prog " + __version__, description=DESCRIPTION) parser.add_option( "-f", "--config-file", type="string", help= "Specifies the python config file. You can also simply specify the config file as the first argument." ) parser.add_option( "-l", "--logging-directory", type="string", default="/var/tmp/lunch", help= "Specifies the logging and pidfile directory for the master. Default is /var/tmp/lunch" ) parser.add_option( "-q", "--log-to-file", action="store_true", help= "Enables logging master infos to file and disables logging to standard output." ) parser.add_option("-g", "--graphical", action="store_true", help="Enables the graphical user interface.") parser.add_option("-v", "--verbose", action="store_true", help="Makes the logging output verbose.") parser.add_option("-d", "--debug", action="store_true", help="Makes the logging output very verbose.") parser.add_option( "-k", "--kill", action="store_true", help= "Kills another lunch master that uses the same config file and logging directory. Exits once it's done." ) (options, args) = parser.parse_args() # --------- set configuration file if options.config_file: config_file = options.config_file DEFAULT_CONFIG_FILE = os.path.expanduser("~/.lunchrc") if len(args) == 1 and not options.config_file: #log.msg("DEBUG: overriding config_file with %s" % (args[0])) config_file = args[0] else: config_file = DEFAULT_CONFIG_FILE # --------- set if logging if options.log_to_file: file_logging_enabled = True else: file_logging_enabled = False logging_dir = options.logging_directory # ---------- load the right reactor if options.graphical: try: from twisted.internet import gtk2reactor gtk2reactor.install() # has to be done before importing reactor import gtk # just for a test GUI_ENABLED = True #print("Successfully loaded the GTK+ graphical user interface.") except ImportError, e: print("Could not load the GTK+ graphical user interface. " + str(e)) GUI_ENABLED = False
OTHER DEALINGS IN THE SOFTWARE. """ import os, sys, platform, subprocess, locale, pickle, json, psutil import pygtk pygtk.require('2.0') import gtk SHARE = os.getenv('TBL_SHARE', sys.prefix+'/share/torbrowser-launcher') import gettext gettext.install('torbrowser-launcher', os.path.join(SHARE, 'locale')) from twisted.internet import gtk2reactor gtk2reactor.install() class Common: def __init__(self, tbl_version): self.tbl_version = tbl_version # initialize the app self.default_mirror = 'https://dist.torproject.org/' self.discover_arch_lang() self.build_paths() for d in self.paths['dirs']: self.mkdir(self.paths['dirs'][d]) self.load_mirrors() self.load_settings() self.mkdir(self.paths['download_dir'])
#** All rights reserved #** Modification, distribution, and sale of this work is prohibited without #** permission from Washington State University #** #** If this code is used for public research, any resulting publications need #** to cite work done by Brian L. Thomas at the Center for Advanced Study of #** Adaptive Systems (CASAS) at Washington State University. #** #** Contact: Brian L. Thomas ([email protected]) #** Contact: Diane J. Cook ([email protected]) #*****************************************************************************# import sys if "pygtk" in sys.modules: from twisted.internet import gtk2reactor gtk2reactor.install() from twisted.words.protocols.jabber import client, jid, xmlstream from twisted.words.xish import domish from twisted.internet import reactor import copy import datetime import json import re import signal import time import uuid import xml.dom.minidom import xml.etree.ElementTree as ETree import xml.parsers.expat
# the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # Lunch is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Lunch. If not, see <http://www.gnu.org/licenses/>. """ Main GUI of the Lunch Master """ if __name__ == "__main__": from twisted.internet import gtk2reactor gtk2reactor.install() # has to be done before importing reactor from twisted.internet import reactor from twisted.internet import defer from twisted.internet import utils from twisted.python import procutils import gtk import pango import sys import os import textwrap import webbrowser from lunch import __version__ from lunch import dialogs from lunch.states import * from lunch import logger
# License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License along with # this program; if not, write to the Free Software Foundation, Inc., 51 # Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # # Copyright Buildbot Team Members from twisted.internet import gtk2reactor gtk2reactor.install() # @UndefinedVariable import sys import time import pygtk # @UnresolvedImport pygtk.require("2.0") import gobject import gtk # @UnresolvedImport assert(gtk.Window) # in gtk1 it's gtk.GtkWindow from twisted.spread import pb #from buildbot.clients.base import Builder, Client from buildbot.clients.base import StatusClient from buildbot.clients.text import TextClient
def boot(path, gtk=False, gst=True, installReactor=True): # python 2.5 and twisted < 2.5 don't work together pythonMM = sys.version_info[0:2] from twisted.copyright import version twistedMM = tuple([int(n) for n in version.split('.')[0:2]]) if pythonMM >= (2, 5) and twistedMM < (2, 5): raise SystemError("Twisted versions older than 2.5.0 do not work with " "Python 2.5 and newer. " "Please upgrade Twisted or downgrade Python.") if gtk or gst: init_gobject() if gtk: init_kiwi() if gst: from flumotion.configure import configure configure.gst_version = init_gst() global USE_GTK, USE_GST USE_GTK = gtk USE_GST = gst init_option_parser(gtk, gst) # installing the reactor could override our packager's import hooks ... if installReactor: from twisted.internet import gtk2reactor gtk2reactor.install(useGtk=gtk) from twisted.internet import reactor # ... so we install them again here to be safe from flumotion.common import package package.getPackager().install() # this monkeypatched var exists to let reconnecting factories know # when they should warn about a connection being closed, and when # they shouldn't because the system is shutting down. # # there is no race condition here -- the reactor doesn't handle # signals until it is run(). reactor.killed = False def setkilled(killed): reactor.killed = killed reactor.addSystemEventTrigger('before', 'startup', setkilled, False) reactor.addSystemEventTrigger('before', 'shutdown', setkilled, True) from flumotion.twisted import reflect from flumotion.common import errors from flumotion.common import setup setup.setup() from flumotion.common import log log.logTwisted() main = reflect.namedAny(path) wrapped = wrap_for_profiling(main) wrapped.__name__ = main.__name__ try: sys.exit(wrapped(sys.argv)) except (errors.FatalError, SystemError), e: safeprintf(sys.stderr, 'ERROR: %s\n', e) sys.exit(1)
import gtk from twisted.internet.protocol import Protocol, ClientCreator from twisted.internet import gtk2reactor # for gtk-2.0 gtk2reactor.install() #this installs the gtk reactor class MyProg(Protocol): button_send_data = [] larr = "" text = "" def sendMessage(self, msg): self.transport.write("%s\n" % msg) def dataReceived(self, data): self.larr.get_buffer().insert_at_cursor(data) def window(self): # app_window = gtk.Window(gtk.WINDOW_TOPLEVEL) app_window =gtk.Dialog() app_window.set_size_request(500, 350) app_window.set_border_width(10) app_window.set_title("Chat Client") app_window.connect("delete_event", lambda w,e: gtk.main_quit()) app_window.show() return app_window def entry(self, w): entry = gtk.Entry() entry.set_max_length(80) entry.set_width_chars(50) entry.connect("changed", self.enter_callback, entry)
# redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License along with # this program; if not, write to the Free Software Foundation, Inc., 51 # Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # # Copyright Buildbot Team Members from twisted.internet import gtk2reactor gtk2reactor.install() #@UndefinedVariable import sys, time import pygtk #@UnresolvedImport pygtk.require("2.0") import gobject, gtk #@UnresolvedImport assert (gtk.Window) # in gtk1 it's gtk.GtkWindow from twisted.spread import pb #from buildbot.clients.base import Builder, Client from buildbot.clients.base import TextClient, StatusClient from buildbot.util import now from buildbot.status.builder import SUCCESS, WARNINGS, FAILURE, EXCEPTION
# You must obey the GNU General Public License in all respects for all of # the code used other than OpenSSL. If you modify file(s) with this # exception, you may extend this exception to your version of the file(s), # but you are not obligated to do so. If you do not wish to do so, delete # this exception statement from your version. If you delete this exception # statement from all source files in the program, then also delete it here. # # from deluge.log import LOG as log import gobject gobject.set_prgname("deluge") # Install the twisted reactor from twisted.internet import gtk2reactor reactor = gtk2reactor.install() import gettext import locale import pkg_resources import gtk, gtk.glade import sys try: from setproctitle import setproctitle, getproctitle except ImportError: setproctitle = lambda t: None getproctitle = lambda: None # Initialize gettext try:
def run(): """ Main function of the application """ from scenic import configure # command line parsing parser = OptionParser(usage="%prog", version=str(configure.VERSION), description=configure.DESCRIPTION) parser.add_option("-k", "--kiosk", action="store_true", help="Run in kiosk mode") parser.add_option("-l", "--enable-logging", action="store_true", help="Enables logging to file.") parser.add_option( "-L", "--log-file-name", type="string", help= "Specifies the path to the log file. Default is %s. Logging must be enabled for this option value to be useful." % (LOG_FILE_NAME), default=LOG_FILE_NAME) parser.add_option("-f", "--fullscreen", action="store_true", help="Run in fullscreen mode") parser.add_option( "-n", "--disable-v4l2-settings-restoration", action="store_true", help= "Disables the state restoring for the V4L2 input number and video standard at startup" ) parser.add_option( "-v", "--verbose", action="store_true", help="Enables a verbose logging output with info level messages.") parser.add_option( "-d", "--debug", action="store_true", help= "Enables a very verbose logging output with debug level messages. Also add a debug tab in the user interface." ) parser.add_option("-M", "--moo", action="store_true", help="There is no easter egg in this program") (options, args) = parser.parse_args() if not os.environ.has_key('DISPLAY'): print "You need an X11 display to run Scenic." sys.exit(1) level = "warning" if options.verbose: level = "info" if options.debug: level = "debug" if options.enable_logging: start_file_logging(level, os.path.expanduser(options.log_file_name)) log_file_name = options.log_file_name else: start_logging_to_stdout(level) log_file_name = None # FIXME: why are we setting log_file_name to Null before passing it to the Application contructor? from scenic import process process.save_environment_variables(os.environ) if not os.environ.has_key( 'GTK2_RC_FILES'): # FIXME: is this check needed and desired? name = "Darklooks" file_name = os.path.join( os.path.join(configure.THEMES_DIR, name, "gtkrc")) os.environ[ "GTK2_RC_FILES"] = file_name # has to be done before gtk2reactor.install() if "/sbin" not in os.environ["PATH"]: # for ifconfig os.environ["PATH"] += ":/sbin" from twisted.internet import gtk2reactor gtk2reactor.install() # has to be done before importing reactor from twisted.internet import reactor from twisted.internet import error from scenic import application import gtk try: gtk.gdk.Display(os.environ["DISPLAY"]) except RuntimeError, e: msg = "Invalid X11 display: %s. \nYou need an X11 display to run Scenic." % ( os.environ["DISPLAY"]) log.error(msg) print msg sys.exit(1)
def install_gtk2(): """ Install gtk2 reactor, needs to be called bef """ from twisted.internet import gtk2reactor gtk2reactor.install()
def install(): """Configure the twisted mainloop to be run inside the glib mainloop. """ return gtk2reactor.install(False)
#!/usr/bin/env python ''' Modified on 2014-11-07 Created on 2009-11-15 @original_author: [email protected] ''' from twisted.internet import gtk2reactor gtk2reactor.install(True) from twisted.internet import reactor, defer from twisted.internet.protocol import ReconnectingClientFactory from starpy.manager import AMIProtocol, AMIFactory from twisted.internet import task import logging import logging.handlers import yaml from pyslack import SlackClient #asterisk AMI login server = "ASTRISKSERVERNAME" port = 5038 username = "******" secret = "PASSWORD" extensions = {"SIP/200": "YOU", "SIP/201": "Someone else"} log = logging.getLogger("server")
def entry(): """ """ ## Phase 1: ## cortex should not have been imported anywhere, so ## we should not have already chosen a twisted reactor. ## do as much as we can before importing anything else, ## to keep the bootstrap sacred parser = build_parser() options, args = parser.parse_args() nodeconf_file = options.conf # python interpretter compatability: # shell$ cortex -c"import cortex; print cortex.__file__" if args and len(args)==1: fname = args[0] if os.path.exists(fname): print "cortex: assuming this is a file.." interpreter = Interpreter(fname) sandbox = interpreter.namespace() interpreter.ex(sandbox) instructions = sandbox.get('__instructions__', []) agent_specs = sandbox.get('__agents__', []) if instructions and options.conf: raise RuntimeError( "cant use '__instructions__' and " "still pass --conf="+options.conf) elif not instructions and options.conf: sandbox['__universe__'].nodeconf_file = options.conf elif instructions and not options.conf: sandbox['__universe__'].set_instructions(instructions) for agent_spec in agent_specs: if isinstance(agent_spec, (list,tuple)): args, kargs = agent_spec else: args, kargs = [agent_spec], {} sandbox['__universe__'].agents.manage(*args, **kargs) if '.play()' not in open(fname).read(): # FIXME: hack report_if_verbose("This file did not start the universe. allow me") sandbox['__universe__'].play() report_if_verbose("finished running this universe.") return # use the gtk-reactor? if options.gtk_reactor: print "using gtk reactor" from twisted.internet import gtk2reactor # for gtk-2.0 gtk2reactor.install() ## Phase 2: ## trigger the first cortex imports. ## there goes the neighborhood. from cortex.core.universe import Universe from cortex.bin.phase2 import install_nodeconf from cortex.bin.client import use_client from cortex.contrib.reloading_helpers import run as RUN #Universe.directives = options.directives.split(",") # reflect command-line options in universe's config olist = [ x for x in dir(options) if not x.startswith('_') \ and x not in 'read_file read_module ensure_value'.split() ] [setattr(Universe.command_line_options, x, getattr(options,x)) for x in olist] if options.verbose: import cortex cortex.VERBOSE = True # use the cortex api client? if options.client: return use_client(options, args) # python interpretter compatability: # shell$ cortex -c"print 3" # NB: comes after options.client because it might want to consume that elif options.command: exec(options.command) return # run tests? if options.run_tests: from cortex.tests import main return main() # deserialize a saved universe and resume it? if options.universe: verify_file(options.universe) U = pickle.loads(open(options.universe).read()) return U.play() # Invoke the Universe ## After this point it's assumed we're using a node-conf, ## whether it is specified explicitly or assumed. the cases for ## the command-line options should not use 'return' # augment nodeconf with additional services? if options.services: from cortex.core import api services = options.services.split(',') for s in services: api.do([['load_service', (s.strip(),), {}]]) if nodeconf_file: verify_file(nodeconf_file) install_nodeconf(nodeconf_file, options, args) return Universe.play() # Invoke the Universe
def run(): from twisted.internet import gtk2reactor gtk2reactor.install() app.run_app(app.LockedApplication(make_application), app.Options())
# lots of little imports done before anything else so that # we don't get weird stray module errors from flumotion.common import boot boot.init_gobject() boot.init_gst() import gst import gst.interfaces e = gst.element_factory_make('fakesrc') from twisted.internet import gtk2reactor gtk2reactor.install(useGtk=True) import pyexpat # fake out pychecker import gobject import gtk import gtk.glade loop = gobject.MainLoop() gtk.main_iteration() m = pyexpat
def run(): """ Runs the application. """ parser = OptionParser( usage="%prog [config file] [options]", version="%prog " + __version__, description=DESCRIPTION ) parser.add_option( "-f", "--config-file", type="string", help="Specifies the python config file. You can also simply specify the config file as the first argument.", ) parser.add_option( "-l", "--logging-directory", type="string", default="/var/tmp/lunch", help="Specifies the logging and pidfile directory for the master. Default is /var/tmp/lunch", ) parser.add_option( "-q", "--log-to-file", action="store_true", help="Enables logging master infos to file and disables logging to standard output.", ) parser.add_option("-g", "--graphical", action="store_true", help="Enables the graphical user interface.") parser.add_option("-v", "--verbose", action="store_true", help="Makes the logging output verbose.") parser.add_option("-d", "--debug", action="store_true", help="Makes the logging output very verbose.") parser.add_option( "-k", "--kill", action="store_true", help="Kills another lunch master that uses the same config file and logging directory. Exits once it's done.", ) (options, args) = parser.parse_args() # --------- set configuration file if options.config_file: config_file = options.config_file DEFAULT_CONFIG_FILE = os.path.expanduser("~/.lunchrc") if len(args) == 1 and not options.config_file: # log.msg("DEBUG: overriding config_file with %s" % (args[0])) config_file = args[0] else: config_file = DEFAULT_CONFIG_FILE # --------- set if logging if options.log_to_file: file_logging_enabled = True else: file_logging_enabled = False logging_dir = options.logging_directory # ---------- load the right reactor if options.graphical: try: from twisted.internet import gtk2reactor gtk2reactor.install() # has to be done before importing reactor import gtk # just for a test GUI_ENABLED = True # print("Successfully loaded the GTK+ graphical user interface.") except ImportError, e: print("Could not load the GTK+ graphical user interface. " + str(e)) GUI_ENABLED = False
# lots of little imports done before anything else so that # we don't get weird stray module errors from flumotion.common import boot boot.init_gobject() boot.init_gst() import gst import gst.interfaces e = gst.element_factory_make("fakesrc") from twisted.internet import gtk2reactor gtk2reactor.install(useGtk=True) import pyexpat # fake out pychecker import gobject import gtk import gtk.glade loop = gobject.MainLoop() gtk.main_iteration() m = pyexpat
# the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # Lunch is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Lunch. If not, see <http://www.gnu.org/licenses/>. """ Main GUI of the Lunch Master """ if __name__ == "__main__": from twisted.internet import gtk2reactor gtk2reactor.install() # has to be done before importing reactor from twisted.internet import reactor from twisted.internet import defer from twisted.internet import utils from twisted.python import procutils import gtk import pango import sys import os import textwrap import webbrowser from lunch import __version__ from lunch import dialogs from lunch.states import * from lunch import logger
def boot(path, gtk=False, gst=True, installReactor=True): # python 2.5 and twisted < 2.5 don't work together pythonMM = sys.version_info[0:2] from twisted.copyright import version twistedMM = tuple([int(n) for n in version.split('.')[0:2]]) if pythonMM >= (2, 5) and twistedMM < (2, 5): raise SystemError( "Twisted versions older than 2.5.0 do not work with " "Python 2.5 and newer. " "Please upgrade Twisted or downgrade Python.") if gtk or gst: init_gobject() if gst: from flumotion.configure import configure configure.gst_version = init_gst() global USE_GTK, USE_GST USE_GTK=gtk USE_GST=gst init_option_parser(gtk, gst) # installing the reactor could override our packager's import hooks ... if installReactor: from twisted.internet import gtk2reactor gtk2reactor.install(useGtk=gtk) from twisted.internet import reactor # ... so we install them again here to be safe from flumotion.common import package package.getPackager().install() # this monkeypatched var exists to let reconnecting factories know # when they should warn about a connection being closed, and when # they shouldn't because the system is shutting down. # # there is no race condition here -- the reactor doesn't handle # signals until it is run(). reactor.killed = False def setkilled(killed): reactor.killed = killed reactor.addSystemEventTrigger('before', 'startup', setkilled, False) reactor.addSystemEventTrigger('before', 'shutdown', setkilled, True) from flumotion.twisted import reflect from flumotion.common import errors from flumotion.common import setup setup.setup() from flumotion.common import log log.logTwisted() # we redefine catching __pychecker__ = 'no-reuseattr' if os.getenv('FLU_PROFILE'): def catching(proc, *args, **kwargs): import statprof statprof.start() try: return proc(*args, **kwargs) finally: statprof.stop() statprof.display() elif os.getenv('FLU_ATEXIT'): def catching(proc, *args, **kwargs): env = os.getenv('FLU_ATEXIT').split(' ') fqfn = env.pop(0) log.info('atexit', 'FLU_ATEXIT set, will call %s(*%r) on exit', fqfn, env) atexitproc = reflect.namedAny(fqfn) try: return proc(*args, **kwargs) finally: log.info('atexit', 'trying to call %r(*%r)', atexitproc, env) atexitproc(*env) else: def catching(proc, *args, **kwargs): return proc(*args, **kwargs) main = reflect.namedAny(path) try: sys.exit(catching(main, sys.argv)) except (errors.FatalError, SystemError), e: safeprintf(sys.stderr, 'ERROR: %s\n', e) sys.exit(1)
# # Copyright (c) 2014 Sartaj Singh # Licensed under the MIT license. ## """ Development script To run without actually installing Picks up local changes """ # system imports import sys # twisted imports from twisted.internet import gtk2reactor gtk2reactor.install() # install reactor for gui from twisted.internet import reactor # Other imports import main from client import options if __name__ == '__main__': args = options.parse_args() # parse the arguments addresses = [] client = args.client host, port, server = args.iface, args.port, args.server if host != None: addresses.append((host, port, server)) try:
def install(): """Configure the twisted mainloop to be run inside the glib mainloop. """ return gtk2reactor.install(False)
print "Not importing misc.setup" pass # we import docutils before installing the packager to prevent # messing with the datadir which causes epydoc to crash try: import docutils except ImportError: print "Not importing docutils" pass from flumotion.common import boot boot.init_gobject() boot.init_gst() from twisted.internet import gtk2reactor gtk2reactor.install(useGtk=False) # reinstall our import hooks that could have been overridden by # pygtk/pygst ltihooks from flumotion.common import package package.getPackager().install() # monkey patching twisted doc errors from twisted.spread import pb def login(self, credentials, client=None): """Login and get perspective from remote PB server. Currently only credentials implementing IUsernamePassword are supported.
def install_gtk2(): """ Install gtk2 reactor, needs to be called bef """ from twisted.internet import gtk2reactor gtk2reactor.install()
def start_client(interacting_function, queue_dict): from rafcon.gui.config import global_gui_config import os from rafcon.gui.controllers.main_window import MainWindowController from rafcon.gui.views.main_window import MainWindowView import rafcon.gui.singleton as gui_singletons from rafcon.gui.runtime_config import global_runtime_config from rafcon.gui.start import signal_handler import rafcon from rafcon.utils import log from rafcon.utils import plugins from rafcon.core.config import global_config from rafcon.core.storage import storage as global_storage from rafcon.core.state_machine import StateMachine from rafcon.core.states.hierarchy_state import HierarchyState import rafcon.core.singleton as core_singletons from rafcon.core.start import setup_environment # load all plugins specified in the RAFCON_PLUGIN_PATH plugins.load_plugins() import testing_utils # check if twisted is imported if "twisted" in sys.modules.keys(): from twisted.internet import gtk2reactor # needed for glib.idle_add, and signals gtk2reactor.install() from twisted.internet import reactor else: print "Twisted not imported! Thus the gkt2reatcor is not installed!" exit() plugins.run_pre_inits() setup_logger() logger = log.get_logger("start") logger.info("RAFCON launcher") setup_environment() signal.signal(signal.SIGINT, signal_handler) global_config.load(path=os.path.dirname(os.path.abspath(__file__))) global_gui_config.load(path=os.path.dirname(os.path.abspath(__file__))) global_runtime_config.load(path=os.path.dirname(os.path.abspath(__file__))) setup_config = dict() setup_config["net_config_path"] = os.path.abspath(path=os.path.join( os.path.dirname(os.path.abspath(__file__)), "client")) # Initialize library core_singletons.library_manager.initialize() # Create the GUI main_window_view = MainWindowView() state_machine = global_storage.load_state_machine_from_path( testing_utils.get_test_sm_path( os.path.join("unit_test_state_machines", "99_bottles_of_beer_monitoring"))) sm_id = rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) rafcon.core.singleton.state_machine_manager.active_state_machine_id = sm_id sm_manager_model = gui_singletons.state_machine_manager_model main_window_controller = MainWindowController(sm_manager_model, main_window_view) plugins.run_post_inits(setup_config) import threading # this is not recognized by pycharm as the module is loaded in plugins.load_plugins() from monitoring.monitoring_manager import global_monitoring_manager interacting_thread = threading.Thread( target=interacting_function, args=[main_window_controller, global_monitoring_manager, queue_dict]) testing_utils.wait_for_gui() interacting_thread.start() # check if twisted is imported if "twisted" in sys.modules.keys(): reactor.run() else: logger.error( "Client: Twisted is not in sys.modules or twisted is not working! Exiting program ... !" ) os._exit(0) logger.info("Joined root state") # If there is a running state-machine, wait for it to be finished before exiting sm = core_singletons.state_machine_manager.get_active_state_machine() if sm: sm.root_state.join() logger.info("Exiting ...") # this is a ugly process shutdown method but works if gtk or twisted process are still blocking os._exit(0)
# vi:si:et:sw=4:sts=4:ts=4 # PYTHONPATH should be set so that if this is part of a Flumotion project, # it points to misc so we can import setup.py from there try: from misc import setup setup.setup() except ImportError: print "Not importing misc.setup" pass from flumotion.common import boot boot.init_gobject() boot.init_gst() from twisted.internet import gtk2reactor gtk2reactor.install(useGtk=False) # reinstall our import hooks that could have been overridden by # pygtk/pygst ltihooks from flumotion.common import package package.getPackager().install() # monkey patching twisted doc errors from twisted.spread import pb def login(self, credentials, client=None): """Login and get perspective from remote PB server. Currently only credentials implementing IUsernamePassword are supported.
# Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2 '''Entertainer client.''' import sys import gtk from twisted.internet import gtk2reactor gtk2reactor.install( ) # Install the gtk2 reactor before import the real reactor from twisted.internet import reactor from twisted.internet.protocol import ClientCreator from twisted.python.log import startLogging from entertainerlib.client.medialibrary.music import MusicLibrary from entertainerlib.client.medialibrary.images import ImageLibrary from entertainerlib.client.medialibrary.videos import VideoLibrary from entertainerlib.configuration import Configuration from entertainerlib.gui.user_interface import UserInterface from entertainerlib.gui.system_tray_icon import SystemTrayIcon from entertainerlib.network.local.client import EntertainerLocalClientProtocol class Client(object): '''This is a client application of Entertainer. Entertainer's client hooks into the server, and then provides a user interface for the data the server creates.''' def __init__(self): config = Configuration() music_library = MusicLibrary() image_library = ImageLibrary()
# You must obey the GNU General Public License in all respects for all of # the code used other than OpenSSL. If you modify file(s) with this # exception, you may extend this exception to your version of the file(s), # but you are not obligated to do so. If you do not wish to do so, delete # this exception statement from your version. If you delete this exception # statement from all source files in the program, then also delete it here. # # from deluge.log import LOG as log import gobject gobject.set_prgname("deluge") # Install the twisted reactor from twisted.internet import gtk2reactor reactor = gtk2reactor.install() import gettext import locale import pkg_resources import gtk, gtk.glade import sys try: from setproctitle import setproctitle, getproctitle except ImportError: setproctitle = lambda t: None getproctitle = lambda: None # Initialize gettext try: