def connect(self):
host = self._host
port = self._port
if self._fd is None:
#try to find the server on the same sub-net
if host is None or port is None:
udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
# go through all interfaces, and issue broadcast on each
for addr in ip4_broadcast_addresses(host is None):
udp.sendto('Hello',
(addr, protocol.DEFAULT_UDP_SERVER_PORT))
timeout = 3.
server_found = []
while 1:
rlist, _, _ = select.select([udp], [], [], timeout)
if not rlist:
if port is None:
if server_found:
msg = "Could not find the conductor on host %s\n" % self._host
msg += "But other conductor servers replied:\n"
msg += '\n'.join(
('%s on port %s' % (host, port)
for host, port in server_found))
raise ConnectionException(msg)
else:
raise ConnectionException(
"Could not find the conductor")
else:
break
else:
msg, address = udp.recvfrom(8192)
host, port = msg.split('|')
port = int(port)
if self._host == 'localhost':
localhost = socket.gethostname()
if localhost == host:
break
elif self._host is not None and host != self._host:
server_found.append((host, port))
host, port = None, None
timeout = 1.
else:
break
self._host = host
self._port = port
self._fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._fd.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self._fd.setsockopt(socket.SOL_IP, socket.IP_TOS, 0x10)
self._fd.connect((host, port))
self._raw_read_task = gevent.spawn(self._raw_read)
self._cnx = self._fd
if posix_ipc:
self._g_event.clear()
self._fd.sendall(
protocol.message(protocol.POSIX_MQ_QUERY,
socket.gethostname()))
self._g_event.wait(1.)
def connect(self):
host = self._host
port = self._port
if self._fd is None:
#try to find the server on the same sub-net
if host is None or port is None:
udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
# go through all interfaces, and issue broadcast on each
for addr in ip4_broadcast_addresses(host is None):
udp.sendto('Hello',(addr,protocol.DEFAULT_UDP_SERVER_PORT))
timeout = 3.
server_found = []
while 1:
rlist,_,_ = select.select([udp],[],[],timeout)
if not rlist:
if port is None:
if server_found:
msg = "Could not find the conductor on host %s\n" % self._host
msg += "But other conductor servers replied:\n"
msg += '\n'.join(('%s on port %s' % (host,port) for host,port in server_found))
raise ConnectionException(msg)
else:
raise ConnectionException("Could not find the conductor")
else:
break
else:
msg,address = udp.recvfrom(8192)
host,port = msg.split('|')
port = int(port)
if self._host == 'localhost':
localhost = socket.gethostname()
if localhost == host:
break
elif self._host is not None and host != self._host:
server_found.append((host,port))
host,port = None,None
timeout = 1.
else:
break
self._host = host
self._port = port
self._fd = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
self._fd.setsockopt(socket.IPPROTO_TCP,socket.TCP_NODELAY,1)
self._fd.setsockopt(socket.SOL_IP, socket.IP_TOS, 0x10)
self._fd.connect((host,port))
self._raw_read_task = gevent.spawn(self._raw_read)
self._cnx = self._fd
if posix_ipc:
self._g_event.clear()
self._fd.sendall(protocol.message(protocol.POSIX_MQ_QUERY,socket.gethostname()))
self._g_event.wait(1.)
def broadcast_service(self):
if self.listen_address == '0.0.0.0':
raise Exception('NetRNG server: zeroconf currently requires a specific listen address in /etc/netrng.conf')
desc = {'version': __version__}
info = ServiceInfo('_netrng._tcp.local.', '{}._netrng._tcp.local.'.format(socket.gethostname()), socket.inet_aton(self.listen_address), self.port, 0, 0, desc)
log.info('NetRNG server: registering service with Bonjour: %s', info)
self.zeroconf_controller.register_service(info)
def __init__(self, louper, *args, **kwargs):
super(LoupeDashboard, self).__init__(*args, **kwargs)
self.loupe_pool = louper.loupe_pool
self.total_loupes = louper.total_count
self.results = louper.results
self.inputs = louper.input_classes
self.failed_stats = louper.failed_stats
self.fetch_failures = louper.fetch_failures
self.start_time = time.time()
self.tpool = None
self.start_time = kwargs.get("start_time") or time.time()
self.start_cmd = kwargs.get("start_cmd") or " ".join(sys.argv)
self.host_machine = kwargs.get("hostname") or socket.gethostname()
self.open_toolserver_queries = self.get_toolserver_openlog()
if self.open_toolserver_queries > 0:
print "\nNote: there are", self.open_toolserver_queries, "open queries on toolserver\n"
self.send_toolserver_log("start", start_time=self.start_time)
self.toolserver_uptime = self.get_toolserver_uptime()
self.route("/", callback=self.render_dashboard, template="dashboard")
self.route("/summary", callback=self.get_summary_dict, template="summary")
self.route("/all_results", callback=self.get_all_results)
self.route("/static/<filepath:path>", callback=self.serve_static)
self.uninstall(JSONPlugin)
self.install(JSONPlugin(better_dumps))
self.install(TemplatePlugin())
self.sys_peaks = defaultdict(float)
def monitor_worker(self, monitor_socket, log_name):
monitor_socket.linger = 0
poller = zmq.Poller()
poller.register(monitor_socket, zmq.POLLIN)
while True:
socks = poller.poll(1)
gevent.sleep(0.1)
if len(socks) > 0:
data = recv_monitor_message(monitor_socket)
event = data['event']
value = data['value']
if event == zmq.EVENT_CONNECTED:
logger.info('Connected to {0}'.format(log_name))
if 'outgoing' in log_name:
send_zmq_push('inproc://serverRelay', '{0}'.format(Messages.PING))
own_ip = gevent.socket.gethostbyname(socket.gethostname())
send_zmq_push('inproc://serverRelay', '{0} {1}'.format(Messages.IP,
own_ip))
send_zmq_push('inproc://serverRelay', '{0}'.format(Messages.DRONE_CONFIG))
elif 'incomming':
pass
else:
assert False
elif event == zmq.EVENT_DISCONNECTED:
logger.warning('Disconnected from {0}, will reconnect in {1} seconds.'.format(log_name, 5))
gevent.sleep()
def create_self_signed_cert(cert_dir, hostname=None, year=10):
from OpenSSL import crypto, SSL
CERT_FILE = "ssl_certificate.crt"
KEY_FILE = "ssl_self_signed.key"
if not os.path.exists(os.path.join(cert_dir, CERT_FILE)) or not os.path.exists(os.path.join(cert_dir, KEY_FILE)):
k = crypto.PKey()
k.generate_key(crypto.TYPE_RSA, 4096)
cert = crypto.X509()
cert.get_subject().C = "AQ"
cert.get_subject().ST = "State"
cert.get_subject().L = "City"
cert.get_subject().O = "Company"
cert.get_subject().OU = "Organization"
if hostname is None :
cert.get_subject().CN = socket.gethostname()
else:
cert.get_subject().CN = hostname
cert.set_serial_number(1000)
cert.gmtime_adj_notBefore(0)
cert.gmtime_adj_notAfter(year*365*24*60*60)
cert.set_issuer(cert.get_subject())
cert.set_pubkey(k)
cert.sign(k, 'sha1')
with open(os.path.join(cert_dir, CERT_FILE), "wt") as f:
f.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
with open(os.path.join(cert_dir, KEY_FILE), "wt") as f:
f.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, k))
print('Create SSL key and cert done')
else:
print('SSL key and cert already exist')
def _resubscribe(self, url, sid=None):
headers = {'TIMEOUT': 'infinite'}
if sid is not None:
headers['SID'] = sid
else:
host = socket.gethostbyname(socket.gethostname())
headers.update({
"CALLBACK": '<http://%s:8989>' % host,
"NT": "upnp:event"
})
try:
response = requests.request(method="SUBSCRIBE", url=url,
headers=headers)
timeout = 50
try:
timeout = int(response.headers['timeout'].replace('Second-', ''))
except:
log.info("Error parse timeout")
print "Error parse timeout"
timeout = 50
try:
sid = response.headers['sid']
except:
log.info("Error parse sid")
print "Error parse sid"
gevent.spawn_later(timeout, self._resubscribe, url, sid)
except:
log.info("Error parse timeout")
gevent.spawn_later(10, self._resubscribe, url, sid)
def __init__(self): #get server ip (current machine) self.ip = self.ip = socket.gethostbyname(socket.gethostname()) print "Starting server: %s:1337" % self.ip self.chs = Characters.Characters()
def init_global():
global gConfig, CONFIGFILE
parser = OptionParser()
parser.add_option("-c", "--config", dest="config", action="store", default="config.ini",
help="specify a config file to load")
parser.add_option("--signcert_enable",
action="store_true", dest="signcert_enable", default=False,
help="generate ssl cert and key")
parser.add_option("--signcert_directory",
action="store", dest="signcert_directory", default='.',
help="specify the directory to store ssl cert and key file")
parser.add_option("--signcert_year",
action="store", type="int", dest="signcert_year", default=10,
help="specify year to generate ssl cert")
parser.add_option("--signcert_hostname",
action="store", dest="signcert_hostname", default=socket.gethostname(),
help="specify host's name to generate ssl cert")
parser.add_option("--cluster_enable",
action="store_true", dest="cluster_enable", default=False,
help="enable cluster mode")
(options, args) = parser.parse_args()
print('parsing %s...' % options.config)
CONFIGFILE = options.config
gConfig = init_config({'gConfig':gConfig},CONFIGFILE)
# if gConfig['wsgi']['application'].lower() == 'chat_platform':
# gJoinableQueue = gevent.queue.JoinableQueue(maxsize=int(gConfig['chat_platform']['queue']['max_queue_size']))
return options
def handshake(self, sck):
# read conn request
payload = utils.read_payload_response(sck)
log.debug(payload)
resp = WirePayload()
resp.connect_response.auth_method.append(SIMPLE)
resp.connect_response.protocol = "text"
resp.connect_response.server_name = socket.gethostname()
utils.send_payload(sck, resp)
payload = utils.read_payload_response(sck)
if not payload.initial_auth_request.IsInitialized():
return False
resp = WirePayload()
resp.auth_response.complete = True
resp.auth_response.challenge = ""
resp_buf = resp.SerializeToString()
utils.send_payload(sck, resp)
payload = utils.read_payload_response(sck)
if not payload.properties_request.IsInitialized():
return False
resp = WirePayload()
resp.properties_response.server_pid = str(os.getpid())
utils.send_payload(sck, resp)
return True
def monitor_worker(self, monitor_socket, log_name):
monitor_socket.linger = 0
poller = zmq.Poller()
poller.register(monitor_socket, zmq.POLLIN)
while True:
socks = poller.poll(1)
gevent.sleep(0.1)
if len(socks) > 0:
data = recv_monitor_message(monitor_socket)
event = data['event']
value = data['value']
if event == zmq.EVENT_CONNECTED:
logger.info('Connected to {0}'.format(log_name))
if 'outgoing' in log_name:
send_zmq_push('inproc://serverRelay',
'{0}'.format(Messages.PING))
own_ip = gevent.socket.gethostbyname(
socket.gethostname())
send_zmq_push('inproc://serverRelay',
'{0} {1}'.format(Messages.IP, own_ip))
send_zmq_push('inproc://serverRelay',
'{0}'.format(Messages.DRONE_CONFIG))
elif 'incomming':
pass
else:
assert False
elif event == zmq.EVENT_DISCONNECTED:
logger.warning(
'Disconnected from {0}, will reconnect in {1} seconds.'
.format(log_name, 5))
gevent.sleep()
def __init__(self):
self.connected = False
self.user('niaxbot', socket.gethostname(), 'Niaxbot')
self.welcomed = False
self.queries = {}
self.logger = logging.getLogger('irc.server')
self.raw_logger = logging.getLogger('irc.server.raw')
def connect(self):
host = self._host
port = self._port
if self._fd is None:
#try to find the server on the same sub-net
if host is None or port is None:
udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
udp.bind(("", protocol.DEFAULT_UDP_CLIENT_PORT))
udp.sendto(
'Hello',
('255.255.255.255', protocol.DEFAULT_UDP_SERVER_PORT))
timeout = 10.
while 1:
rlist, _, _ = select.select([udp], [], [], timeout)
if not rlist:
if port is None:
raise ConnectionException(
"Could not find the conductor")
else:
break
else:
msg, address = udp.recvfrom(8192)
host, port = msg.split('|')
port = int(port)
if self._host == 'localhost':
localhost = socket.gethostname()
if localhost == host:
break
elif self._host is not None and host != self._host:
host, port = None, None
timeout = 1.
else:
break
self._fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._fd.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self._fd.connect((host, port))
self._raw_read_task = gevent.spawn(self._raw_read)
self._cnx = self._fd
if posix_ipc:
self._g_event.clear()
self._fd.sendall(
protocol.message(protocol.POSIX_MQ_QUERY,
socket.gethostname()))
self._g_event.wait(1.)
def __init__(self, ca=None, cert=None, key=None, hostname=None):
self._hosts = []
self._ca = ca
self._cert = cert
self._key = key
if hostname is None:
hostname = socket.gethostname()
self._hostname = hostname
def __init__(self):
self.subscribed = 0
self._generator = None
self.fqdn = socket.getfqdn()
self.hostname = socket.gethostname()
self._events = Queue()
self.register()
def __init__(self):
self.subscribed = 0
self._generator = None
self.fqdn = socket.getfqdn()
self.hostname = socket.gethostname()
self._events = Queue()
self.register()
def connect(self) :
host = self._host
port = self._port
if self._fd is None:
#try to find the server on the same sub-net
if host is None or port is None:
udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
udp.bind(("",protocol.DEFAULT_UDP_CLIENT_PORT))
# go through all interfaces, and issue broadcast on each
for addr in ip4_broadcast_addresses():
udp.sendto('Hello',(addr,protocol.DEFAULT_UDP_SERVER_PORT))
timeout = 3.
while 1:
rlist,_,_ = select.select([udp],[],[],timeout)
if not rlist:
if port is None:
raise ConnectionException("Could not find the conductor")
else:
break
else:
msg,address = udp.recvfrom(8192)
host,port = msg.split('|')
port = int(port)
if self._host == 'localhost':
localhost = socket.gethostname()
if localhost == host:
break
elif self._host is not None and host != self._host:
host,port = None,None
timeout = 1.
else:
break
self._fd = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
self._fd.setsockopt(socket.IPPROTO_TCP,socket.TCP_NODELAY,1)
self._fd.connect((host,port))
self._raw_read_task = gevent.spawn(self._raw_read)
self._cnx = self._fd
if posix_ipc:
self._g_event.clear()
self._fd.sendall(protocol.message(protocol.POSIX_MQ_QUERY,socket.gethostname()))
self._g_event.wait(1.)
def connect(self, port):
host_name = socket.gethostname()
try:
self.socket = socket.create_connection((host_name, port))
except socket.error as exc:
self.logger.error('Could not connect to %s, because of %s',
(host_name, port, exc))
return False
self.logger.info('Connected to %s', (host_name, port))
return True
def __init__(self, handler, mcast_ip='239.255.255.250', mcast_port=1900, bind=None):
if bind is None:
host = socket.gethostbyname(socket.gethostname())
port = 54321
bind = '{0}:{1}'.format(host, port)
self.bind = bind
self.mcast_ip = mcast_ip
self.mcast_port = mcast_port
self.clients = {}
self._handler = handler
def __init__(self, actor_config, batch=0, batch_size=1, set_size=1, sleep=1, value=1, tags=()):
Actor.__init__(self, actor_config)
if batch == 0:
self.generateNextBatchAllowed = self.__returnTrue
else:
self.generateNextBatchAllowed = self.__evaluateCounter
self.pool.createQueue("outbox")
self.hostname = gethostname()
def connect(self, port):
host_name = socket.gethostname()
try:
self.socket = socket.create_connection((host_name, port))
except socket.error as exc:
self.logger.error('Could not connect to %s, because of %s',
(host_name, port, exc))
return False
self.logger.info('Connected to %s', (host_name, port))
return True
def connect(self):
if self.host is None:
self.host = socket.gethostname()
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if self.port is None:
self.sock.bind((self.host, 0))
self.port = self.sock.getsockname()[1]
else:
self.sock.bind((self.host, self.port))
_log.debug('Bound to %r on %r' % (self.port, self.host))
def server():
#start server running
s = socket.socket()
host = socket.gethostname()
address = (host, 5000)
s.bind(address)
s.listen(1)
while True:
conn, addr = s.accept()
if debug: print(conn)
buffer_length = 8
message_complete = False
response = b''
while not message_complete:
part = conn.recv(buffer_length)
response += part
if len(part) < buffer_length:
break
message = response
#returns resource (file ext) from get request
resource = parse_request(message)
#resolve_uri takes resource from packet sent and opens file gets data repackages
packet = resolve_uri(resource)
#encodes http packet created and sends to client
conn.send(packet.encode())
strMessage = message.decode()
if debug: print(resource)
#tests functionality before http packet was added
#ok response
if strMessage == "testOK":
ok = response_ok()
conn.send(ok.encode())
#test sending error response
if strMessage == "testError":
error = response_error()
conn.send(error.encode())
conn.close()
if message.decode() == 'q':
break
def __init__(self,
name,
port=None,
host=None,
listen=True,
*args,
**kwargs):
super(TCPOut, self).__init__(name, *args, **kwargs)
self.blockdiag_config["shape"] = "cloud"
self.port = port or DEFAULT_PORT
self.host = host or socket.gethostbyname(socket.gethostname())
def metricProducer(self):
'''A greenthread which collects the queue metrics at the defined interval.'''
self.__run.wait()
hostname = socket.gethostname()
while self.loop():
for queue in self.pool.listQueues(names=True):
for metric, value in self.pool.getQueue(queue).stats().iteritems():
event = Wishbone_Event(self.name)
event.data = Metric(time=time(), type="wishbone", source=hostname, name="module.%s.queue.%s.%s" % (self.name, queue, metric), value=value, unit="", tags=())
self.submit(event, self.pool.queue.metrics)
sleep(self.frequency)
def __init__(self, node_name, port, cookie, connected_event=None):
super(OutgoingNodeConnection, self).__init__()
self.port = port
self.cookie = cookie
if '@' in node_name:
self.node_name = node_name
else:
self.node_name = '{}@{}'.format(node_name, socket.gethostname())
self.channel = Channel(self.actor_ref)
self.channel.connect(self.port)
self.connected_event = connected_event
self._state = None
def __init__(self, node_name, port, cookie, connected_event=None):
super(OutgoingNodeConnection, self).__init__()
self.port = port
self.cookie = cookie
if '@' in node_name:
self.node_name = node_name
else:
self.node_name = '{}@{}'.format(node_name, socket.gethostname())
self.channel = Channel(self.actor_ref)
self.channel.connect(self.port)
self.connected_event = connected_event
self._state = None
def __init__(self, config):
self.config = config
self.interval = config['master']['heartbeat_secs']
self.hostname = socket.gethostname()
self.port = config['worker']['port']
self.slots = self.max_slots = config['worker']['available_slots']
self.secret = config['master']['shared_secret']
self.min_srv_port = config['worker']['port_range_start']
self.max_srv_port = config['worker']['port_range_end']
self.srv_port = self.min_srv_port
self.matches = {}
self.heartbeat_greenlet = gevent.spawn(self.send_heartbeat)
def cli(host, port, wwwport):
click.echo('\r\nService listening on %s:%s' % (
host,
port,
))
web_list = list()
client_connect_list = list()
web_list.append('local: http://127.0.0.1:%s' % wwwport)
client_connect_list.append(
'local: python client.py --host 127.0.0.1 --port %s' % port)
if host == '0.0.0.0':
wan_ip = get_wan_ip()
lan_ip = socket.gethostbyname(socket.gethostname())
if lan_ip != wan_ip:
web_list.append('lan : http://%s:%s' % (lan_ip, wwwport))
client_connect_list.append(
'lan : python client.py --host %s --port %s' % (lan_ip, port))
if wan_ip:
web_list.append(
'wan : http://%s:%s PS: Maybe need to set up port forwarding'
% (wan_ip, wwwport))
client_connect_list.append(
'wan : python client.py --host %s --port %s PS: Maybe need to set up port forwarding'
% (wan_ip, port))
click.echo('\r\nAccess console via:')
for item in web_list:
click.echo(item)
click.echo('\r\nClient connection use:')
for item in client_connect_list:
click.echo(item)
click.echo('\r\nListening ...')
global_process_var = Manager().dict()
GlobalHelper.init(global_process_var)
web_ui = Process(target=web_start,
args=(global_process_var, host, wwwport))
web_ui.start()
global slave_record
slave_record = SlaveRecord.get_instance()
GlobalHelper.set('salve_record', slave_record.slave_record)
socket_server(host, port)
web_ui.join()
def get_host_ip():
ret = []
if sys.platform == 'win32':
ret.append('127.0.0.1')
localIP = socket.gethostbyname(socket.gethostname())
#print ("local ip:%s " % localIP)
ipList = socket.gethostbyname_ex(socket.gethostname())
for i in ipList:
if i != localIP:
#if isinstance(i, str):
#print(re.findall('\d+\.\d+\.\d+\.\d+',i))
if isinstance(i, list):
for ii in i:
if len(re.findall('\d+\.\d+\.\d+\.\d+',ii))>0:
ret.append(ii)
#print("external IP:%s" % i )
elif 'linux' in sys.platform:
import commands
ips = commands.getoutput("/sbin/ifconfig | grep -i \"inet\" | grep -iv \"inet6\" | awk {'print $2'} | sed -ne 's/addr\:/ /p'")
arr = ips.split('\n')
for i in arr:
ret.append(i.strip())
return ret
def __init__(self,
handler,
mcast_ip='239.255.255.250',
mcast_port=1900,
bind=None):
if bind is None:
host = socket.gethostbyname(socket.gethostname())
port = 54321
bind = '{0}:{1}'.format(host, port)
self.bind = bind
self.mcast_ip = mcast_ip
self.mcast_port = mcast_port
self.clients = {}
self._handler = handler
def __init__(self, hostname, nick, port=IRC_PORT,
local_hostname=None, server_name=None, real_name=None):
self.hostname = hostname
self.port = port
self.nick = nick
self._socket = None
self.real_name = real_name or nick
self.local_hostname = local_hostname or socket.gethostname()
self.server_name = server_name or 'gevent-irc'
self._recv_queue = gevent.queue.Queue()
self._send_queue = gevent.queue.Queue()
self._group = gevent.pool.Group()
self._handlers = {}
self._global_handlers = set([])
class RpcChannel(service.RpcChannel):
def __init__(self, addr, port):
self._seq_id = 0
self._addr = addr
self._port = port
self._conn = None
self.reconnect()
self._rlock = Semaphore()
self._wlock = Semaphore()
def reconnect(self):
if self._conn != None:
self._conn.close()
try:
sck = socket.create_connection((self._addr, self._port))
except socket.error, e:
raise RpcException(e)
self._seq_id += 1
# send connect request
req = WirePayload()
req.connect_request.version = 1 << 16
utils.send_payload(sck, req)
payload = utils.read_payload_response(sck)
if not payload.connect_response.IsInitialized():
raise
# send initauth request
req = WirePayload()
req.initial_auth_request.auth_method = SIMPLE
req.initial_auth_request.initial_response = "wdj-rpc"
utils.send_payload(sck, req)
payload = utils.read_payload_response(sck)
if not payload.auth_response.IsInitialized():
raise
# send properties request
req = WirePayload()
req.properties_request.client_host_name = socket.gethostname()
req.properties_request.client_port = 1234
req.properties_request.client_pid = str(os.getpid())
utils.send_payload(sck, req)
payload = utils.read_payload_response(sck)
if not payload.properties_response.IsInitialized():
raise
self._conn = sck
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(WINDOW_SIZE)
self.w, self.h = WINDOW_SIZE[0], WINDOW_SIZE[1]
self.screen.fill((255,255,255))
pygame.display.flip()
self.ip = socket.gethostbyname(socket.gethostname())
print "Client IP: %s" % self.ip
#self.serverip = raw_input("What is the server IP address?\n\n")
self.serverip = '192.168.1.100'
self.serverport = '1337'
print "\n-----------------------\n\n"
def handle(self):
send_ack = True
response = False
try:
self.process_query()
response = True
except socket.error as e:
self.logger.error("Failed connection from %s (child of %s): %s."\
%(repr(self.address), repr(self.server.address),
unicode(e)))
except NetworkException as e:
self.logger.error("RaisedNetworkException:\n"+unicode(e))
e.log_forward((socket.gethostname(),self.server.address[1]))
self.send(e)
send_ack = False
except Exception as e:
self.logger.error("RaisedException:\n"+traceback.format_exc())
ne = NetworkException(type(e).__name__+': '+unicode(e))
ne.log_forward((socket.gethostname(),self.server.address[1]))
self.send(ne)
send_ack = False
finally:
if __debug__: self.logger.debug("executing finally statement.")
try:
if send_ack:
self.send(0 if response else -1)
if __debug__: self.logger.debug("Closing connection.")
self.socket.shutdown(socket.SHUT_WR)
self.socket.close()
except Exception as e:
if __debug__: self.logger.debug("ERROR: %s",unicode(e))
pass
def __init__(self, hostname, nick, port=IRC_PORT,
local_hostname=None, server_name=None, real_name=None, ssl=False, logger=None):
self.hostname = hostname
self.port = port
self.nick = nick
self.ssl = ssl
self._socket = None
self.real_name = real_name or nick
self.local_hostname = local_hostname or socket.gethostname() #@UndefinedVariable
self.server_name = server_name or 'gevent-irc'
self._recv_queue = gevent.queue.Queue()
self._send_queue = gevent.queue.Queue()
self._group = gevent.pool.Group()
self._handlers = {}
self._global_handlers = set()
self.channels = set()
self.logger = logger or module_logger
def __init__(self,
actor_config,
batch=0,
batch_size=1,
set_size=1,
sleep=1,
value=1,
tags=()):
Actor.__init__(self, actor_config)
if batch == 0:
self.generateNextBatchAllowed = self.__returnTrue
else:
self.generateNextBatchAllowed = self.__evaluateCounter
self.pool.createQueue("outbox")
self.hostname = gethostname()
def getLocalIP():
''' Get the local IP address as a string
Derived from https://github.com/n8henrie/fauxmo
'''
hostname = socket.gethostname()
ip_address = socket.gethostbyname(hostname)
# Workaround for Linux returning localhost
# See: SO question #166506 by @UnkwnTech
if ip_address in ['127.0.1.1', '127.0.0.1', 'localhost']:
tempsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
tempsock.connect(('8.8.8.8', 0))
ip_address = tempsock.getsockname()[0]
tempsock.close()
return ip_address
def _resubscribe(self, url, sid=None):
headers = {'TIMEOUT': 'infinite'}
if sid is not None:
headers['SID'] = sid
else:
host = socket.gethostbyname(socket.gethostname())
headers.update({
"CALLBACK": '<http://%s:8989>' % host,
"NT": "upnp:event"
})
response = requests.request(method="SUBSCRIBE",
url=url,
headers=headers)
timeout = int(response.headers['timeout'].replace('Second-', ''))
sid = response.headers['sid']
gevent.spawn_later(timeout, self._resubscribe, url, sid)
def cli(host, port, wwwport):
click.echo('\r\nService listening on %s:%s' % (host, port,))
web_list = list()
client_connect_list = list()
web_list.append('local: http://127.0.0.1:%s' % wwwport)
client_connect_list.append('local: python client.py --host 127.0.0.1 --port %s' % port)
if host == '0.0.0.0':
wan_ip = get_wan_ip()
lan_ip = socket.gethostbyname(socket.gethostname())
if lan_ip != wan_ip:
web_list.append('lan : http://%s:%s' % (lan_ip, wwwport))
client_connect_list.append('lan : python client.py --host %s --port %s' % (lan_ip, port))
if wan_ip:
web_list.append('wan : http://%s:%s PS: Maybe need to set up port forwarding' % (wan_ip, wwwport))
client_connect_list.append(
'wan : python client.py --host %s --port %s PS: Maybe need to set up port forwarding' %
(wan_ip, port))
click.echo('\r\nAccess console via:')
for item in web_list:
click.echo(item)
click.echo('\r\nClient connection use:')
for item in client_connect_list:
click.echo(item)
click.echo('\r\nListening ...')
global_process_var = Manager().dict()
GlobalHelper.init(global_process_var)
web_ui = Process(target=web_start, args=(global_process_var, host, wwwport))
web_ui.start()
global slave_record
slave_record = SlaveRecord.get_instance()
GlobalHelper.set('salve_record', slave_record.slave_record)
socket_server(host, port)
web_ui.join()
def _send_posix_mq_connection(client_id, client_hostname):
ok_flag = False
try:
if posix_ipc is not None and not isinstance(client_id, posix_ipc.MessageQueue):
if client_hostname == socket.gethostname(): # same host
# open a message queue
new_mq = _PosixQueue()
client_id._pmq = new_mq
mq_name = new_mq.names()
ok_flag = True
except:
import traceback
traceback.print_exc()
finally:
if ok_flag:
client_id.sendall(protocol.message(protocol.POSIX_MQ_OK, "|".join(mq_name)))
return new_mq
else:
client_id.sendall(protocol.message(protocol.POSIX_MQ_FAILED))
def index(self):
start_time = time.time()
host = socket.gethostname() # 获取本地主机名
port = 12345 # 设置端口号
s = socket.create_connection((host, port), 30)
s.sendall("11")
watcher = gevent.get_hub().loop.io(s.fileno(), 1)
watcher.start(s.recv(8))
s.close()
# s = socket.socket() # 创建 socket 对象
# s.connect((host, port))
# s.send("11")
total_time = int((time.time() - start_time) * 1000)
events.request_success.fire(request_type="Request",
name="test",
response_time=total_time,
response_length=0)
def metricProducer(self):
'''A greenthread which collects the queue metrics at the defined interval.'''
self.__run.wait()
hostname = socket.gethostname()
while self.loop():
for queue in self.pool.listQueues(names=True):
for metric, value in list(
self.pool.getQueue(queue).stats().items()):
metric = Metric(time=time(),
type="wishbone",
source=hostname,
name="module.%s.queue.%s.%s" %
(self.name, queue, metric),
value=value,
unit="",
tags=())
event = Wishbone_Event(metric)
self.submit(event, self.pool.queue.metrics)
sleep(self.frequency)
def pair(self, env):
uuid = env['mapper.vault']
if not check_uuid4(uuid):
raise HTTPReturn(http.NOT_FOUND)
model = instance(Model)
vault = model.get_vault(uuid)
if not vault:
raise HTTPReturn(http.NOT_FOUND)
self._do_auth_hmac_cb(uuid)
# Sign the certificate request that was sent to tus
certinfo = self.entity
if not certinfo or not isinstance(certinfo, dict):
raise HTTPReturn(http.BAD_REQUEST)
model.add_certificate(uuid, certinfo)
# And send our own certificate request in return
certinfo = { 'node': vault['node'], 'name': socket.gethostname() }
certkeys = certinfo['keys'] = {}
for key in vault['keys']:
certkeys[key] = { 'key': vault['keys'][key]['public'],
'keytype': vault['keys'][key]['keytype'] }
return certinfo
def __metricProducer(self):
'''
A greenthread collecting the queue metrics at the defined interval.
'''
self._run.wait()
hostname = socket.gethostname()
while self.loop():
for queue in self.pool.listQueues(names=True):
for metric, value in list(self.pool.getQueue(queue).stats().items()):
event = Wishbone_Event({
"time": time(),
"type": "wishbone",
"source": hostname,
"name": "module.%s.queue.%s.%s" % (self.name, queue, metric),
"value": value,
"unit": "",
"tags": ()
})
self.submit(event, "_metrics")
sleep(self.config.frequency)
def _send_posix_mq_connection(client_id, client_hostname):
ok_flag = False
try:
if (posix_ipc is not None
and not isinstance(client_id, posix_ipc.MessageQueue)):
if client_hostname == socket.gethostname(): # same host
#open a message queue
new_mq = _PosixQueue()
client_id._pmq = new_mq
mq_name = new_mq.names()
ok_flag = True
except:
import traceback
traceback.print_exc()
finally:
if ok_flag:
client_id.sendall(
protocol.message(protocol.POSIX_MQ_OK, '|'.join(mq_name)))
return new_mq
else:
client_id.sendall(protocol.message(protocol.POSIX_MQ_FAILED))
def __init__(self,
host='',
port=0,
local_hostname=None,
timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
"""Initialize a new instance.
If specified, `host' is the name of the remote host to which to
connect. If specified, `port' specifies the port to which to connect.
By default, smtplib.SMTP_PORT is used. If a host is specified the
connect method is called, and if it returns anything other than a
success code an SMTPConnectError is raised. If specified,
`local_hostname` is used as the FQDN of the local host for the
HELO/EHLO command. Otherwise, the local hostname is found using
socket.getfqdn().
"""
self.timeout = timeout
self.esmtp_features = {}
if host:
(code, msg) = self.connect(host, port)
if code != 220:
raise SMTPConnectError(code, msg)
if local_hostname is not None:
self.local_hostname = local_hostname
else:
# RFC 2821 says we should use the fqdn in the EHLO/HELO verb, and
# if that can't be calculated, that we should use a domain literal
# instead (essentially an encoded IP address like [A.B.C.D]).
fqdn = socket.getfqdn()
if '.' in fqdn:
self.local_hostname = fqdn
else:
# We can't find an fqdn hostname, so use a domain literal
addr = '127.0.0.1'
try:
addr = socket.gethostbyname(socket.gethostname())
except socket.gaierror:
pass
self.local_hostname = '[%s]' % addr
def pair(self, env):
uuid = env['mapper.vault']
if not check_uuid4(uuid):
raise HTTPReturn(http.NOT_FOUND)
model = instance(Model)
vault = model.get_vault(uuid)
if not vault:
raise HTTPReturn(http.NOT_FOUND)
self._do_auth_hmac_cb(uuid)
# Sign the certificate request that was sent to tus
certinfo = self.entity
if not certinfo or not isinstance(certinfo, dict):
raise HTTPReturn(http.BAD_REQUEST)
model.add_certificate(uuid, certinfo)
# And send our own certificate request in return
certinfo = {'node': vault['node'], 'name': socket.gethostname()}
certkeys = certinfo['keys'] = {}
for key in vault['keys']:
certkeys[key] = {
'key': vault['keys'][key]['public'],
'keytype': vault['keys'][key]['keytype']
}
return certinfo
def main(): # proxy server part
import signal, os
global pipe_write
pipe_read, pipe_write = os.pipe()
def _stop_server(*args):
#import os
os.close(pipe_write)
signal.signal(signal.SIGINT, _stop_server)
signal.signal(signal.SIGTERM, _stop_server)
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--channel-name",
dest="channel_name",
default=None,
help="channel where proxy url is stored")
parser.add_argument("--host", dest="host", help="destination host")
parser.add_argument("--port",
dest="port",
type=int,
help="destination port")
_options = parser.parse_args()
tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcp.bind(("", 0))
tcp.listen(16)
proxy_port = tcp.getsockname()[1]
proxy_host = socket.gethostname()
server_url = "%s:%d" % (proxy_host, proxy_port)
global dont_reset_channel
dont_reset_channel = False
def channel_cbk(value):
global dont_reset_channel
if value != server_url:
dont_reset_channel = True
try:
os.close(pipe_write)
except OSError:
pass
channel_name = _options.channel_name or 'proxy:%s:%d' % (_options.host,
_options.port)
channel = Channel(channel_name, value=server_url, callback=channel_cbk)
runFlag = True
fd_list = [tcp, pipe_read]
global client
global dest
client = None
dest = None
try:
while runFlag:
rlist, _, _ = select.select(fd_list, [], [])
for s in rlist:
if s == tcp:
accept_flag = True
try:
if dest is None:
dest = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
dest.setsockopt(socket.IPPROTO_TCP,
socket.TCP_NODELAY, 1)
dest.connect((_options.host, _options.port))
fd_list.append(dest)
except:
dest = None
accept_flag = False
if client is not None:
fd_list.remove(client)
client.close()
client = None
client, addr = tcp.accept()
if accept_flag:
client.setsockopt(socket.IPPROTO_TCP,
socket.TCP_NODELAY, 1)
fd_list.append(client)
else:
client.close()
client = None
elif s == client:
try:
raw_data = client.recv(16 * 1024)
except:
raw_data = None
if raw_data:
dest.sendall(raw_data)
else:
fd_list.remove(client)
client.close()
client = None
elif s == dest:
try:
raw_data = dest.recv(16 * 1024)
except:
raw_data = None
if raw_data:
client.sendall(raw_data)
else:
dest.close()
fd_list.remove(dest)
dest = None
fd_list.remove(client)
client.close()
client = None
elif s == pipe_read:
runFlag = False
break
finally:
if dont_reset_channel is False:
channel.value = None
gevent.sleep(0)
def get_hostname():
return socket.gethostname()
def __init__(self, handler, mcast_ip="239.255.255.250", port=1900):
self.ip = socket.gethostbyname(socket.gethostname())
self.mcast_ip = mcast_ip
self.port = port
self.clients = {}
self._handler = handler
#!/usr/bin/python3
from gevent import socket
s = socket.socket()
host = socket.gethostname()
port = 8002
s.bind((host, port))
s.listen(5)
s.settimeout(4)
while True:
while True:
try:
c, addr = s.accept()
break
except socket.timeout:
print 'timeout'
pass
try:
c.settimeout(4)
c.sendall('f**k you')
except socket.timeout:
print 'timeout sending'
break
try:
import simplejson as json
except ImportError:
import json # pyflakes.ignore
from . import protocol as nsq
from . import errors
from .message import Message
from .httpclient import HTTPClient
from .states import INIT, CONNECTED, DISCONNECTED
from .stream import Stream
from .decorators import cached_property
from .version import __version__
HOSTNAME = socket.gethostname()
SHORTNAME = HOSTNAME.split('.')[0]
USERAGENT = 'gnsq/%s' % __version__
class Nsqd(HTTPClient):
"""Low level object representing a TCP or HTTP connection to nsqd.
:param address: the host or ip address of the nsqd
:param tcp_port: the nsqd tcp port to connect to
:param http_port: the nsqd http port to connect to
:param timeout: the timeout for read/write operations (in seconds)
def __init__(self, name, port=None, host=None, listen=True, *args, **kwargs):
super(TCPOut, self).__init__(name, *args, **kwargs)
self.blockdiag_config["shape"] = "cloud"
self.port = port or DEFAULT_PORT
self.host = host or socket.gethostbyname(socket.gethostname())
def _get_hostname(self):
name = socket.gethostname()
pos = name.find('.')
if pos != -1:
name = name[:pos]
return name
* round trip info for recent downloads.
* failure rate per host ...
"""
while True:
gevent.sleep(SLOT_HEARTBEAT_INTERVAL)
self.sched.reportSlots(slot_list)
if __name__ == "__main__":
if len(argv) != 2:
print >> sys.stdout, "Usage: %s <pack_id>" % (os.path.basename(argv[0]), )
sys.exit(-1)
## machine id
import socket
ip = socket.gethostbyname(socket.gethostname())
if not ip:
raise "Need to get IP address as machine Id!"
## pack id
pack_id = 0
try:
pack_id = int(argv[1])
except ValueError:
print >> sys.stdout, "Usage: %s <pack_id>" % (os.path.basename(argv[0]), )
sys.exit(-1)
pack = SpiderPack(ip, pack_id, 5)
pack.run()
