def fetchServicesData():
try:
while True:
global serviceDictionary,lock
global webServerUrls,loadBalancerServerURL
lock.acquire()
serviceDictionary = {}
urlArray = webServerUrls
for url in urlArray:
try:
client = Client(url,cache = NoCache(),timeout=30)
key = url.split('?')[0]
serviceDictionary.update({key:[]})
for method in client.wsdl.services[0].ports[0].methods.values():
serviceDictionary[key].append(method.name)
except Exception as e:
if hasattr(e,'reason') and e.reason.message == 'timed out':
webServerUrls.remove(url)
elif hasattr(e,'reason') and (e.reason.errno == 111 or e.reason.errno == 10061):
webServerUrls.remove(url)
continue
for loadurl in loadBalancerServerURL:
try:
client = Client(loadurl,cache = NoCache(),timeout=30)
except Exception as e:
if hasattr(e,'reason') and e.reason.message == 'timed out':
loadBalancerServerURL.remove(loadurl)
elif hasattr(e,'reason') and (e.reason.errno == 111 or e.reason.errno == 10061):
loadBalancerServerURL.remove(loadurl)
continue
lock.release()
time.sleep(5)
except Exception as identifier:
pass
def __init__(self,
xaddr,
user,
passwd,
url,
cache_location='/tmp/suds',
cache_duration=None,
encrypt=True,
daemon=False,
ws_client=None,
no_cache=False,
portType=None,
dt_diff=None):
if not os.path.isfile(url):
raise ONVIFError('%s doesn`t exist!' % url)
if no_cache:
cache = NoCache()
else:
# Create cache object
# NOTE: if cache_location is specified,
# onvif must has the permission to access it.
cache = ObjectCache(location=cache_location)
# cache_duration: cache will expire in `cache_duration` days
if cache_duration is not None:
cache.setduration(days=cache_duration)
# Convert pathname to url
self.url = urlparse.urljoin('file:', urllib.pathname2url(url))
self.xaddr = xaddr
# Create soap client
if not ws_client:
self.ws_client = Client(
url=self.url,
location=self.xaddr,
cache=cache,
port=portType,
headers={'Content-Type': 'application/soap+xml'})
else:
self.ws_client = ws_client
self.ws_client.set_options(location=self.xaddr)
# Set soap header for authentication
self.user = user
self.passwd = passwd
# Indicate wether password digest is needed
self.encrypt = encrypt
self.daemon = daemon
self.dt_diff = dt_diff
if self.user is not None and self.passwd is not None:
self.set_wsse()
# Method to create type instance of service method defined in WSDL
self.create_type = self.ws_client.factory.create
def _get_siif(self,
retornaXML=False,
unverified_context=False,
check_wsdl=False):
"""
Establece la conexión con el WS y crea el objeto SOAP cliente de dicha conexión.
"""
if not check_wsdl: #Web
self.local_wsdl = False
# Obtener la URL de parámetros del sistema
url_siif = self.env['ir.config_parameter'].get_param(
'url_ws.siif', '')
if not url_siif or url_siif == '0':
_logger.info(
'Servicio Web SIIF: No se pudo conectar con el servicio.')
return False, 'Error!\n %s' % (
'No se encuentra configurada la ruta del WSDL para consumir los servicios SIIF',
)
# Establecer la conexión
try:
return True, Client(url_siif,
cache=NoCache(),
retxml=retornaXML)
except Exception as e:
return False, 'Error!\n %s' % (
'Ha ocurrido un error en la comunicación web con SIIF', )
else:
self.local_wsdl = True
try:
sys.stdout = codecs.getwriter(locale.getpreferredencoding())(
sys.stdout)
path_file = os.path.dirname(os.path.abspath(__file__))
ultima_barra = path_file.rfind('/')
path_new = path_file[:ultima_barra]
if unverified_context:
try:
_create_unverified_https_context = ssl._create_unverified_context
except AttributeError:
# Legacy Python that doesn't verify HTTPS certificates by default
pass
else:
# Handle target environment that doesn't support HTTPS verification
ssl._create_default_https_context = _create_unverified_https_context
# Construcción del objeto clente SOAP
url = 'file://' + path_new + '/CGNSiiF.wsdl'
return True, Client(url,
plugins=[LogPlugin()],
cache=NoCache(),
retxml=retornaXML)
except Exception as e:
return False, 'Error!\n %s' % (
u'Ha ocurrido un error en la comunicación local con SIIF',
)
def __init__(self, xaddr, user, passwd, url,
cache_location='/tmp/suds', cache_duration=None,
encrypt=True, daemon=False, ws_client=None, no_cache=False, portType=None, dt_diff = None):
if not os.path.isfile(url):
raise ONVIFError('%s doesn`t exist!' % url)
if no_cache:
cache = NoCache()
else:
# Create cache object
# NOTE: if cache_location is specified,
# onvif must has the permission to access it.
cache = ObjectCache(location=cache_location)
# cache_duration: cache will expire in `cache_duration` days
if cache_duration is not None:
cache.setduration(days=cache_duration)
# Convert pathname to url
self.url = urlparse.urljoin('file:', urllib.pathname2url(url))
self.xaddr = xaddr
# Create soap client
if not ws_client:
self.ws_client = Client(url=self.url,
location=self.xaddr,
cache=cache,
port=portType,
headers={'Content-Type': 'application/soap+xml'})
else:
self.ws_client = ws_client
self.ws_client.set_options(location=self.xaddr)
# Set soap header for authentication
self.user = user
self.passwd = passwd
# Indicate wether password digest is needed
self.encrypt = encrypt
self.daemon = daemon
self.dt_diff = dt_diff
if self.user is not None and self.passwd is not None:
self.set_wsse()
# Method to create type instance of service method defined in WSDL
self.create_type = self.ws_client.factory.create
def __init__(self, **kwargs):
domain = __name__
definitions = [
Definition('cache', Cache, NoCache()),
Definition('faults', bool, True),
Definition('transport', suds.transport.options.Options,
suds.transport.options.Options()),
Definition('service', (int, basestring), None),
Definition('port', (int, basestring), None),
Definition('location', basestring, None),
Definition('soapheaders', (), ()),
Definition('wsse', suds.wsse.options.Options,
suds.wsse.options.Options()),
Definition('doctor', Doctor, None),
Definition('wsaddr', bool, False),
Definition('xstq', bool, True),
Definition('prefixes', bool, True),
Definition('retxml', bool, False),
Definition('prettyxml', bool, False),
Definition('autoblend', bool, False),
Definition('cachingpolicy', int, 0),
Definition('plugins', (list, tuple), []),
Definition('nosend', bool, False),
Definition('enforcepolicy', bool, True),
]
Skin.__init__(self, Properties(domain, definitions, kwargs))
def _setup(self):
plugings = []
cache_conf = NoCache()
if Configuration.debug:
if Configuration.log_file is not None:
logging.basicConfig(filename=Configuration.log_file, level=Configuration.log_level,
format=utils.get_log_format())
else:
logging.basicConfig(level=Configuration.log_level,
format=utils.get_log_format())
if Configuration.log_level == logging.DEBUG and Configuration.environment == constants.PRODUCTION_ENV:
raise LogException
plugings.append(LogPlugin())
s = requests.Session()
s.mount('file://', FileAdapter())
if Configuration.proxy_url:
s.proxies = utils.get_builded_proxy_url(Configuration.proxy_url, Configuration.proxy_port)
if Configuration.proxy_user:
s.auth= HTTPProxyAuth(Configuration.proxy_user, Configuration.proxy_pass)
if Configuration.certificate and Configuration.c_key:
s.cert=(Configuration.certificate, Configuration.c_key)
else:
s.verify = Configuration.certificate
t = RequestsTransport(s, timeout=Configuration.timeout)
if Configuration.cache:
cache_conf = ObjectCache(location=Configuration.cache_location, seconds=Configuration.cache_duration)
self._client = client.Client(Configuration.get_wsdl().strip(), plugins=plugings, transport=t, cache=cache_conf)
def __init__(self,
oauth2_client,
application_name,
network_code=None,
https_proxy=None,
cache=NoCache()):
"""Initializes a DfpClient.
For more information on these arguments, see our SOAP headers guide:
https://developers.google.com/doubleclick-publishers/docs/soap_xml
Args:
oauth2_client: A googleads.oauth2.GoogleOAuth2Client used to authorize
your requests.
application_name: An arbitrary string which will be used to identify your
application
[optional]
network_code: A string identifying the network code of the network you are
accessing. All requests other than getAllNetworks and getCurrentUser
calls require this header to be set.
https_proxy: A string identifying the URL of a proxy that all HTTPS
requests should be routed through.
cache: A subclass of suds.cache.Cache that defaults to NoCache.
"""
self.oauth2_client = oauth2_client
self.application_name = application_name
self.network_code = network_code
self.https_proxy = https_proxy
self.cache = cache
self._header_handler = _DfpHeaderHandler(self)
def getSessionId(self, client, serviceUrl):
try:
#proxy_settings = dict(http='http://localhost:8081')
#clientSDK = Client(serviceUrl + "?wsdl", cache=NoCache(), timeout=1200, proxy=proxy_settings)
clientSDK = Client(serviceUrl + "?wsdl",
timeout=1200,
cache=NoCache())
CxLogin = clientSDK.factory.create("Credentials")
CxLogin.User = self.USERNAME
CxLogin.Pass = self.PASSWORD
cxSDK = clientSDK.service.Login(CxLogin, 1033)
if not cxSDK.IsSuccesfull:
raise Exception("Unable to Login > %s" % cxSDK.ErrorMessage)
if self.DEBUG:
print "Service Object:", dir(client)
print "Login Object:", dir(cxSDK)
print "Session ID:", cxSDK.SessionId
return (cxSDK.SessionId, clientSDK)
except Exception as e:
raise Exception("Unable to get SessionId from [%s] : %s" %
(serviceUrl, e.message))
def request(self, start_date, end_date):
imp = Import('http://theaffiliategateway.com/data/schemas')
client = Client(self.url, doctor=ImportDoctor(imp), cache=NoCache())
authentication = client.factory.create('AuthenticationType')
authentication.username = self.username
authentication.apikey = self.password
criteria = client.factory.create('CriteriaType')
criteria.StartDateTime = start_date.isoformat() + ' 00:00:00'
criteria.EndDateTime = end_date.isoformat() + ' ' + '00:00:00'
result = client.service.GetSalesData(authentication, criteria)
data = []
if result.Transactions:
for transaction in result.Transactions.Transaction:
entry = dict()
for field in transaction:
entry[field[0]] = field[1]
data.append(entry)
output = pandas.DataFrame()
if len(data) > 0:
output = output.append(data, ignore_index=True)
output = output.rename(columns=lambda x: 'ag:' + x)
return output
def __init__(self, **kwargs):
domain = __name__
definitions = [
Definition('cache', Cache, NoCache()),
Definition('documentStore', DocumentStore, defaultDocumentStore),
Definition('extraArgumentErrors', bool, True),
Definition('allowUnknownMessageParts', bool, False),
Definition('faults', bool, True),
Definition('transport', Transport, None, TpLinker()),
Definition('service', (int, basestring), None),
Definition('port', (int, basestring), None),
Definition('location', basestring, None),
Definition('soapheaders', (), ()),
Definition('wsse', Security, None),
Definition('doctor', Doctor, None),
Definition('xstq', bool, True),
Definition('prefixes', bool, True),
Definition('retxml', bool, False),
Definition('prettyxml', bool, False),
Definition('autoblend', bool, False),
Definition('cachingpolicy', int, 0),
Definition('plugins', (list, tuple), []),
Definition('nosend', bool, False),
Definition('unwrap', bool, True),
Definition('sortNamespaces', bool, True)
]
Skin.__init__(self, domain, definitions, kwargs)
def __init__(self, **kwargs):
domain = __name__
default_envns = ('SOAP-ENV',
'http://schemas.xmlsoap.org/soap/envelope/')
definitions = [
Definition('cache', Cache, NoCache()),
Definition('faults', bool, True),
Definition('transport', Transport, None, TpLinker()),
Definition('service', (int, basestring), None),
Definition('port', (int, basestring), None),
Definition('location', basestring, None),
Definition('envns', tuple, default_envns),
Definition('soapheaders', (), ()),
Definition('wsse', Security, None),
Definition('doctor', Doctor, None),
Definition('xstq', bool, True),
Definition('prefixes', bool, True),
Definition('retxml', bool, False),
Definition('prettyxml', bool, False),
Definition('autoblend', bool, False),
Definition('cachingpolicy', int, 0),
Definition('plugins', (list, tuple), []),
Definition('nosend', bool, False),
]
Skin.__init__(self, domain, definitions, kwargs)
def __init__(self,
username,
oauth2_client,
application_name,
https_proxy=None,
cache=NoCache()):
"""Initializes a DfaClient.
For more information on these arguments, see our SOAP headers guide:
https://developers.google.com/doubleclick-advertisers/docs/SOAP_headers
Args:
username: A string representation of your DFA username. This is likely not
the same as your Google Account name.
oauth2_client: A googleads.oauth2.GoogleOAuth2Client used to authorize
your requests.
application_name: An arbitrary string which will be used to identify your
application
[optional]
https_proxy: A string identifying the URL of a proxy that all HTTPS
requests should be routed through.
cache: A subclass of suds.cache.Cache that defaults to NoCache.
"""
self.username = username
self.oauth2_client = oauth2_client
self.application_name = application_name
self.https_proxy = https_proxy
self.cache = cache
self._header_handler = _DfaHeaderHandler(self)
def setUp(self):
self.longMessage = True
client = Client(
'%s/medfreq/wsdl/' % self.live_server_url,
cache=NoCache(),
)
self.client = client
def _get_wslsp_obj(self, no_cache=False):
self.ensure_one()
client = False
if no_cache:
client = Client(self.url, cache=NoCache())
ws = self._webservice_class(self, url=self.url, client=client)
return ws
def _get_client(self):
"""
contacts the webservice and gets a client with suds
:return: client object
"""
url = 'https://bioinfoweb.sch.nhs.uk/QPulseWeb.asmx?WSDL'
client = Client(url, cache=NoCache())
return client
def cache(self):
"""
Get the cache.
@return: The I{cache} when I{cachingpolicy} = B{1}.
@rtype: L{Cache}
"""
if self.options.cachingpolicy == 1:
return self.options.cache
return NoCache()
def setUp(self):
self.network_code = '12345'
self.application_name = 'application name'
self.oauth2_client = 'unused'
self.https_proxy = 'myproxy.com:443'
self.cache = NoCache()
self.version = sorted(googleads.dfp._SERVICE_MAP.keys())[-1]
self.dfp_client = googleads.dfp.DfpClient(
self.oauth2_client, self.application_name, self.network_code,
self.https_proxy, self.cache)
def cache(self):
"""
Get the cache.
@return: The I{options} when I{cachingpolicy} = B{0}.
@rtype: L{Cache}
"""
if self.options.cachingpolicy == 0:
return self.options.cache
else:
return NoCache()
def setUp(self):
self.username = '******'
self.application_name = 'application name'
self.oauth2_client = 'unused'
self.https_proxy = 'myproxy.com:443'
self.cache = NoCache()
self.dfa_client = googleads.dfa.DfaClient(self.username,
self.oauth2_client,
self.application_name,
self.https_proxy, self.cache)
def get_session_id(service_url, user_name, password, lcid=2052):
"""
Login in Checkmarx and retrieve the Session ID
https://checkmarx.atlassian.net/wiki/display/KC/Initiating+a+Session
The login web service parameters are as follows:
public CxWSResponseLoginData Login(
Credentials applicationCredentials,
int lcid
);
applicationCredentials: A Credentials object, with fields:
User: The username for login
Pass: The password for login
lcid: ID# of the language for web service responses.
The current API version supports the following values:
1033: English
1028: Chinese Taiwan
1041: Japanese
2052: Chinese
Log in Checkmarx and retrieve the session id.
The Checkmarx server session timeout is 24 hours.
:param service_url:
:param user_name:
:param password:
:param lcid:
:return:
"""
try:
client_sdk = Client(service_url + "?wsdl",
cache=NoCache(),
prettyxml=True)
cx_login = client_sdk.factory.create("Credentials")
cx_login.User = user_name
cx_login.Pass = password
cx_sdk = client_sdk.service.Login(cx_login, lcid)
if not cx_sdk.IsSuccesfull:
logger.error("Unable to Login > " "{}".format(cx_sdk.ErrorMessage))
raise Exception("Unable to Login > "
"{}".format(cx_sdk.ErrorMessage))
return cx_sdk.SessionId, client_sdk
except Exception as e:
logger.error("Unable to get SessionId from "
"[{}] : {} ".format(service_url, e.message))
raise Exception("Unable to get SessionId from "
"[{}] : {} ".format(service_url, e.message))
def setUp(self):
self.cache = NoCache()
self.dev_token = 'developers developers developers'
self.user_agent = 'users users user'
self.oauth2_client = 'unused'
self.https_proxy = 'my.proxy:443'
self.adwords_client = googleads.adwords.AdWordsClient(
self.dev_token,
self.oauth2_client,
self.user_agent,
https_proxy=self.https_proxy,
cache=self.cache)
def add_replica(self, replica_uri):
logging.info('TM: add_replica() called.')
if len(self._replicas)==0:
logging.debug('TM: replica added: %s', replica_uri)
self._replicas = []
self._replicaURIs = []
self._replicaURIs.append(replica_uri)
self._replicas.append(Client(replica_uri, cache=NoCache()))
elif replica_uri not in self._replicaURIs:
logging.debug('TM: replica added: %s', replica_uri)
self._replicaURIs.append(replica_uri)
self._replicas.append(replica_uri)
def send(
intelligenceTypeId,
iodefTypeId,
filepath,
account,
pwd,
url,
cert_path,
key_path,
toUnitIds=2,
):
try:
client = Client(
url=url,
cache=NoCache(),
transport=HTTPSClientCertTransport(
cert=cert_path,
key=key_path,
),
)
except Exception as e:
logging.exception('Exception when connecting to server.')
raise
try:
with open(filepath, 'rb') as f:
doc = base64.b64encode(f.read()).decode()
except Exception as e:
logging.exception('Exception when reading iodef.')
raise
try:
checksum = md5sum(filepath)
except Exception as e:
logging.exception('Exception when calculating md5sum.')
raise
try:
response = client.service.uploadIodefFile(
account=account,
pwd=pwd,
toUnitIds=toUnitIds,
intelligenceTypeId=intelligenceTypeId,
iodefTypeId=iodefTypeId,
doc=doc,
checksum=checksum,
)
except Exception as e:
logging.exception('Exception when sending to server.')
raise
return response
def request_p0(url, user, password, xml_str):
t = HttpAuthenticated(username=user, password=password)
base64string = base64.encodestring('%s:%s' % (user, password)).replace(
'\n', '')
auth_header = {"Authorization": "Basic %s" % base64string}
try:
client = Client(url, retxml=True, transport=t, cache=NoCache())
except urllib2.URLError as e:
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
client = Client(url, retxml=True, transport=t, cache=NoCache())
client.set_options(headers=auth_header)
# Clean XML
xml_str = xml_str.strip()
xml_str = xml_str.replace("'utf-8'", "'UTF-8'")
xml_str = xml_str.replace("<?xml version='1.0' encoding='UTF-8'?>", "")
xml_str = Raw(xml_str)
# Send request
res = client.service.sync(xml_str)
try:
def find_child(element, child_name):
res = None
if child_name in element.tag:
return element
for child in element:
res = find_child(child, child_name)
if res is not None:
break
return res
aux = etree.fromstring(res)
aux_res = find_child(aux, "MensajeEnvioInformacionPS")
res = etree.tostring(aux_res)
except Exception:
pass
return res
def set_client(self, settings):
for key in settings.iterkeys():
setattr(self, key, settings.get(key))
base64string = base64.encodestring(
'%s:%s' % (self.username, self.password)).replace('\n', '')
authenticationHeader = {
"SOAPAction": "ActionName",
"Authorization": "Basic %s" % base64string
}
t = HttpAuthenticated(username=self.username, password=self.password)
self._client = Client(self.url,
headers=authenticationHeader,
transport=t,
cache=NoCache(),
timeout=500)
def soap_call(wsdl_url, methodname, method_args):
"""Calls a SOAP webmethod at a given URL with given arguments."""
client = Client(wsdl_url, cache=NoCache())
try:
method = getattr(client.service, methodname)
except MethodNotFound as error:
return(error)
try:
response = method(*method_args)
except WebFault as error:
return(error)
return response
def _get_client(self):
"""
contacts the webservice and gets a client with suds
:return: client object
"""
try:
_create_unverified_https_context = ssl._create_unverified_context
except AttributeError:
pass
else:
ssl._create_default_https_context = _create_unverified_https_context
url = 'https://bioinfoweb.sch.nhs.uk/UserAuthentication.asmx?WSDL'
client = Client(url, cache=NoCache())
return client
def connection():
"""
Bu metod Zato suds proxy kullanimi icin patch yapilana kadar burada duracak.
:return: suds client
"""
# conn = self.outgoing.soap['YOKSIS Akademik Birim Agaci'].conn
# cli = conn.client()
from suds.client import Client
from suds.cache import NoCache
wsdl = 'http://servisler.yok.gov.tr/ws/UniversiteBirimlerv1?WSDL'
proxy = {'http': 'services.konya.edu.tr:3128'}
cli = Client(wsdl, cache=NoCache(), proxy=proxy)
cli.set_options(faults=False)
return cli
def __init__(self, client_id, client_secret, refresh_token,
manager_account_id, dev_token):
"""Initializes an APIHandler.
Args:
client_id: The client customer id retrieved from the Developers Console.
client_secret: The client secret retrieved from the Developers Console.
refresh_token: The refresh token retrieved with generate_refresh_token.py.
manager_account_id: The AdWords manager account Id.
dev_token: The AdWords Developer Token.
"""
credentials = GoogleRefreshTokenClient(client_id, client_secret,
refresh_token)
self.client = AdWordsClient(dev_token, credentials, self._USER_AGENT,
client_customer_id=manager_account_id,
cache=NoCache())
def main(argv):
#Command line arguments
serverFile = None
try:
opts, args = getopt.getopt(argv, "hF:", ["serverFile="])
except getopt.GetoptError:
print './replica_config.py -F <serverFile>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print './replica_config.py -F <serverFile>'
sys.exit()
elif opt in ("-F", "--serverFile="):
serverFile = arg
#Read server address file and append to list
if serverFile is None:
logging.error("serverFile is needed to add replicas.")
sys.exit(1)
sfile = None
try:
sfile = open(serverFile, 'r')
except:
logging.error("error while trying to open the serverFile")
sys.exit(1)
servers = []
for line in sfile:
addr = line.strip('\n').split(' ')
uri = 'http://' + addr[0] + ':' + addr[
1] + '/?wsdl' #'http://localhost:7789/?wsdl'
logging.info("replica uri: %s", uri)
servers.append(uri)
#Create a client & add replica to each server
logging.info("Establishing connection with servers...")
for server in servers:
client = Client(uri, cache=NoCache(), timeout=120)
client.service.set_server(server)
# Add replicas
for replica in servers:
if replica.find(server) == -1:
client.service.add_replica(replica)
logging.info("Connections b/w servers is setup.")
sys.exit(0)
def setUp(self):
oauth_header = {'Authorization': 'header'}
self.cache = NoCache()
self.client_customer_id = 'client customer id'
self.dev_token = 'developers developers developers'
self.user_agent = 'users users user'
self.oauth2_client = mock.Mock()
self.oauth2_client.CreateHttpHeader.return_value = dict(oauth_header)
self.https_proxy = 'my.proxy:443'
self.adwords_client = googleads.adwords.AdWordsClient(
self.dev_token,
self.oauth2_client,
self.user_agent,
client_customer_id=self.client_customer_id,
https_proxy=self.https_proxy,
cache=self.cache)
self.header_handler = googleads.adwords._AdWordsHeaderHandler(
self.adwords_client, CURRENT_VERSION)
