Das deutsche Python-Forum

Code: Alles auswählen

cwd = os.getcwd()
sys.path.append(cwd)
print('Adding current path to PYTHONPATH: ' + cwd)
                          
import GFP.source


thread.start_new_thread(GFP.source.run, (False,
                                               VCAT_SOURCE_HOST_LOCAL,    
                                               DATA_FROM_GFP_PORT_LOCAL,
                                               VCAT_SOURCE_FILE0,
                                               GFP_BASE_DIR)))
thread.start_new_thread(GFP.source.run, (False,
                                               VCAT_SOURCE_HOST REMOTE,    
                                               DATA_FROM_GFP_PORT_REMOTE,
                                               VCAT_SOURCE_FILE1,
                                               GFP_BASE_DIR)))

Code: Alles auswählen

class Counter:
  def __init__(self):
     self.value = 0
  def inc(self):
     self.value += 1

a = Counter()
b = Counter()
c = Counter()

from threading import Thread

def f(c1, c2):
  for i in range(100):
     c1.inc()
     c2.inc()

t1 = Thread(target=f, args=(a, b))
t1.start()

t2 = Thread(target=f, args=(a, c))
t2.start()

print a.value, b.value, c.value

Code: Alles auswählen

$GFP_BASE_DIR/source.py                                 \
        --VCAT_host     $VCAT_SOURCE_HOST_LOCAL         \
        --VCAT_port     $DATA_FROM_GFP_PORT_LOCAL       \
        --infile        $VCAT_SOURCE_FILE               \
        --basedir       $GFP_BASE_DIR                   &
childPids=( "${childPids[@]}" $! )

$GFP_BASE_DIR/source.py                                 \
        --VCAT_host     $VCAT_SOURCE_HOST_REMOTE        \
        --VCAT_port     $DATA_FROM_GFP_PORT_REMOTE      \
        --infile        $VCAT_SOURCE_FILE               \
        --basedir       $GFP_BASE_DIR                   &
childPids=( "${childPids[@]}" $! )

Code: Alles auswählen

 
import sys

def run(verbose, 
        VCAT_host, VCAT_port, 
        input_filespec, base_directory):
  
  if VCAT_host == -1:
    VCAT_host = 'localhost'
  if VCAT_port == -1:
    VCAT_port = 16000
  if base_directory == -1:
    base_directory = '.'
  if input_filespec == -1:
    input_filespec = 'ITUT_G7042_LCAS.pdf'
  input_filespec = base_directory + '/' + input_filespec
  if verbose:
    print "\nGenerating data for a VCAT flow"
    print indent, 'VCAT source host is', VCAT_host
    print indent, 'VCAT source port is', VCAT_port
    print indent, 'Basedir is', base_directory
    print indent, 'Input file is', input_filespec
    print ''
  
  #-------------------------------------------------------------------------------
  # Instanciate an object of GFP data source class
  #
  
  if verbose:
    verbosity = 1
  else:
    verbosity = None
  
  source = GFP_source('file data',
                      VCAT_host,
                      VCAT_port,
                      input_filespec,
                      verbosity)

################################################################################
# Define the GFP data source class
#
                                                      # define project libraries
from channel.tx       import Tx
from channel.thread   import Thread
from channel.common   import DataHandler
from channel.common   import Error
from channel.api      import *
from Common.VCAT_LCAS import *
                                              # define the GFP data source class
class GFP_source(Thread):
  def __init__(self,
               name,
               Tx_host,
               Tx_port,
               filespec,
               verbosity = None):
    Thread.__init__(self, name, verbosity)

    #---- create the output channel and start connections
    self.output = Tx(self,
                     'out',
                     data_from_GFP_request_nb,
                     (Tx_host, Tx_port),
                     verbosity)
    self.start()
    
    #---- run this IP's core function
    try:
      self.main(filespec)
    except Error:
      self.msg('Error in "main", time to leave.', -2)
      self.kill(True)


  #--------------------------------------------------- data generation from file
  def generate_data(self):
    new_block = self.STREAM.read(GFP_packet_length)
    return new_block


  #================================================================ data queuing
  def main(self, input_filespec):
    #----INITIALISATION
    #---- open the data file
    self.STREAM = open(input_filespec, 'rb')

    #---- START WORKING
    #---- prepare packets to be requested by the sink
    output_buffers = []
    for index in range(self.output.size):
      new_block = self.generate_data()
      self.msg('Preparing to send ' + repr(new_block))
      dh = DataHandler(new_block)
      output_buffers.append(dh)
      Send(self.output, dh, data_from_GFP_message_length)
    
    output_buffers_pointer = 0
    #---- main loop: prepare a new packet as one has been sent
    while True:

      #---- wait for a message to be sent
      Wait(self.output)

      #---- prepare a new packet
      new_block = self.generate_data()
      self.msg('Preparing to send ' + repr(new_block))

      #---- queue it on the output channel
      dh = output_buffers[output_buffers_pointer]
      dh.setData(new_block)
      Send(self.output, dh, data_from_GFP_message_length)

      #---- increment the buffer pinter modulo the buffer length
      output_buffers_pointer = (output_buffers_pointer + 1) % self.output.size

Code: Alles auswählen

import sys, time, os

#-------------------------------------------------------------------------------
# Add local directory to the Python path
cwd = os.getcwd()
sys.path.append(cwd)
print('Adding current path to PYTHONPATH: ' + cwd)

cmd = 'python class1.py 1'
arg = '1'
p = os.popen(cmd)
z = os.popen(cmd)

#Started all thread
while(1):
  time.sleep(1)

Code: Alles auswählen

import sys

class class1:

    def __init__(self, verbosity):
      print ('started')
      print (repr(verbosity))
      self.main(verbosity)
      
    def main(self, verbosity):
      self.globalvar = 0
      while True:
        if verbosity:
          print 'class 1 says hello and globalvar = ' + repr(self.globalvar)
          self.globalvar = self.globalvar+1
          if self.globalvar == 5000:
            sys.exit(1)

minArgs = 1
if len(sys.argv) > minArgs:
    verbosity = int(sys.argv[minArgs])
else:
    verbosity = None    
s = class1(verbosity)

Code: Alles auswählen

cmd = 'python class1.py'
arg = '1'
p = subprocess.Popen([cmd, arg])

Code: Alles auswählen

subprocess.Popen(['python', 'class1.py', '1'])