def __init__(
            self,
            host=cfg.cucm_host,
            username=cfg.cucm_user,
            password=cfg.cucm_pass,
            timeout=30):

        self.host = host
        self.username = username
        self.password = password
        self.timeout = timeout
        wsdl = 'https://' + host + \
            ':8443/logcollectionservice2/services/LogCollectionPortTypeService?wsdl'
        location = 'https://' + host + \
            ':8443/logcollectionservice2/services/LogCollectionPortTypeService'

        t = HttpAuthenticated(username=self.username,
                              password=self.password, timeout=timeout)
        t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)

        ssl_def_context = ssl.create_default_context()
        ssl_def_context.check_hostname = False
        ssl_def_context.verify_mode = ssl.CERT_NONE

        t1 = urllib.request.HTTPSHandler(context=ssl_def_context)
        t.urlopener = urllib.request.build_opener(t.handler, t1)

        self.client = Client(
            wsdl,
            location=location,
            username=username,
            password=password,
            cache=None,
            transport=t
        )
Exemple #2
0
    def __init__(self, username, password, wsdl, cucm, cucm_version=10):
        """
        :param username: axl username
        :param password: axl password
        :param wsdl: wsdl file location
        :param cucm: UCM IP address
        :param cucm_version: UCM version
        """
        self.username = username
        self.password = password
        self.wsdl = wsdl
        self.cucm = cucm
        self.cucm_version = cucm_version

        tns = 'http://schemas.cisco.com/ast/soap/'
        imp = Import('http://schemas.xmlsoap.org/soap/encoding/',
                     'http://schemas.xmlsoap.org/soap/encoding/')
        imp.filter.add(tns)

        t = HttpAuthenticated(username=self.username, password=self.password)
        t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)

        ssl_def_context = ssl.create_default_context()
        ssl_def_context.check_hostname = False
        ssl_def_context.verify_mode = ssl.CERT_NONE

        t1 = urllib.request.HTTPSHandler(context=ssl_def_context)
        t.urlopener = urllib.request.build_opener(t.handler, t1)

        self.client = Client(self.wsdl,
                             location='https://{0}:8443/axl/'.format(cucm),
                             faults=False,
                             plugins=[ImportDoctor(imp)],
                             transport=t)
Exemple #3
0
    def __init__(self, username, password, cucm, cucm_version):
        """
        :param username: ris username
        :param password: ris password
        :param cucm: UCM IP address
        :param cucm_version: UCM version

        example usage:
        >>> from ris import RIS
        >>> ucm = RIS('ris_user', 'ris_pass', '192.168.200.10', '11.5')
        """
        self.username = username
        self.password = password
        self.wsdl = 'https://'+cucm+':8443//realtimeservice2/services/RISService70?wsdl'
        self.cucm = cucm
        self.cucm_version = cucm_version


        tns = 'http://schemas.cisco.com/ast/soap/'
        imp = Import('http://schemas.xmlsoap.org/soap/encoding/', 'http://schemas.xmlsoap.org/soap/encoding/')
        imp.filter.add(tns)

        t = HttpAuthenticated(username=self.username, password=self.password)
        t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)
        
        ssl_def_context = ssl.create_default_context()
        ssl_def_context.check_hostname = False
        ssl_def_context.verify_mode = ssl.CERT_NONE

        t1 = urllib.request.HTTPSHandler(context=ssl_def_context)
        t.urlopener = urllib.request.build_opener(t.handler, t1)

        self.client = Client(self.wsdl, location='https://{0}:8443/realtimeservice2/services/RISService70'.format(cucm), faults=False,
                             plugins=[ImportDoctor(imp)],
                             transport=t)
Exemple #4
0
 def axlSQL():
     #get AXL information from GUI
     info = connectAXL()
     location = info.get('location')
     username = info.get('username')
     password = info.get('password')
     wsdl = info.get('wsdl')
     t = HttpAuthenticated(username=username, password=password)
     t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)
     ssl_def_context = ssl.create_default_context()
     ssl_def_context.check_hostname = False
     ssl_def_context.verify_mode = ssl.CERT_NONE
     ssl_def_context.set_ciphers('HIGH:!DH:!aNULL')
     t1 = urllib.request.HTTPSHandler(context=ssl_def_context)
     t.urlopener = urllib.request.build_opener(t.handler, t1)
     try:
         client = Client(wsdl,
                         location=location,
                         plugins=[ImportDoctor(imp)],
                         transport=t)
         try:
             result = client.service.executeSQLQuery(
                 "select ProcessNode.name as ProcessNode, ProcessConfig.paramname,ProcessConfig.paramvalue as ProcessConfig from processconfig,processnode where ProcessConfig.fkprocessnode = ProcessNode.pkid"
             )
             car.clearTable()
             for node in result['return']['row']:
                 car.LoadTable(str(node['processnode']),
                               str(node['paramname']),
                               str(node['processconfig']), '')
         except Exception as e:
             logger.critical(e)
     except Exception as e:
         logger.critical(e)
Exemple #5
0
def setup_connection():
    result = urllib2.install_opener(urllib2.build_opener(HTTPSHandlerV3()))
    logging.raiseExceptions = 0

    beamlineScheduleServiceURL = base + \
         'beamlineScheduleService/beamlineScheduleWebService.wsdl'

    runScheduleServiceURL = base + \
         'runScheduleService/runScheduleWebService.wsdl'

    try:
        credentials = dict(username=username, password=password)
        t = HttpAuthenticated(**credentials)
        if debug:
            print t.u2handlers()
            print t.credentials()
        runScheduleServiceClient = Client(runScheduleServiceURL)
        runScheduleServiceClient.options.cache.setduration(seconds=10)
        result = setSoapHeader(runScheduleServiceClient, username, password)
        beamlineScheduleServiceClient = Client(beamlineScheduleServiceURL)
        beamlineScheduleServiceClient.options.cache.setduration(seconds=10)
        result = setSoapHeader(beamlineScheduleServiceClient, username, password)
    except Exception, ex:
        print "CANNOT OPEN SERVICES:" + str(ex)
        raise
        exit(-1)
Exemple #6
0
 def button_testaxl_callback():
     info = connectAXL()
     location = info.get('location')
     username = info.get('username')
     password = info.get('password')
     wsdl = info.get('wsdl')
     t = HttpAuthenticated(username=username, password=password)
     t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)
     ssl_def_context = ssl.create_default_context()
     ssl_def_context.check_hostname = False
     ssl_def_context.verify_mode = ssl.CERT_NONE
     ssl_def_context.set_ciphers('HIGH:!DH:!aNULL')
     t1 = urllib.request.HTTPSHandler(context=ssl_def_context)
     t.urlopener = urllib.request.build_opener(t.handler, t1)
     try:
         client = Client(wsdl,
                         location=location,
                         plugins=[ImportDoctor(imp)],
                         transport=t)
         resp = client.service.getCCMVersion()
         version = resp['return'].componentVersion.version
         logger.info('Successfully tested to Call Manager : ' + version)
     except Exception as e:
         logger.error('Failed to connect to ' + location)
         logger.critical(e)
Exemple #7
0
 def axlinsertSQL(server, name, newval):
     #get AXL information from GUI
     info = connectAXL()
     location = info.get('location')
     username = info.get('username')
     password = info.get('password')
     wsdl = info.get('wsdl')
     t = HttpAuthenticated(username=username, password=password)
     t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)
     ssl_def_context = ssl.create_default_context()
     ssl_def_context.check_hostname = False
     ssl_def_context.verify_mode = ssl.CERT_NONE
     ssl_def_context.set_ciphers('HIGH:!DH:!aNULL')
     t1 = urllib.request.HTTPSHandler(context=ssl_def_context)
     t.urlopener = urllib.request.build_opener(t.handler, t1)
     try:
         client = Client(wsdl,
                         location=location,
                         plugins=[ImportDoctor(imp)],
                         transport=t)
         try:
             sqlStr = "insert into processconfig(paramvalue,paramname,tkservice,tkparam,fkprocessnode) values ('" + newval + "','" + name + "','0','2',(select ProcessNode.pkid from Processnode where ProcessNode.name='" + server + "'))"
             result = client.service.executeSQLUpdate(sqlStr)
             logger.info("Successfully inserted " + name + " to '" +
                         newval + "' on " + server)
         except Exception as e:
             logger.critical(e)
     except Exception as e:
         logger.critical(e)
Exemple #8
0
def get_auth_stub(config):
    """
    Given a config dict in the format:

        {'clientid': ... your ET client ID ...,
         'clientsecret': ... your ET client secret ...}

    ... return an auth stub to be used when making requests.
    """
    LOGGER.info("Generating auth stub...")

    params = {
        'clientid': config['client_id'],
        'clientsecret': config['client_secret']
        }

    if config.get('tenant_subdomain'):
        # For S10+ accounts: https://developer.salesforce.com/docs/atlas.en-us.noversion.mc-apis.meta/mc-apis/your-subdomain-tenant-specific-endpoints.htm

        params['authenticationurl'] = ('https://{}.auth.marketingcloudapis.com/v1/requestToken'
                                       .format(config['tenant_subdomain']))
        LOGGER.info("Authentication URL is: %s", params['authenticationurl'])
        params['soapendpoint'] = ('https://{}.soap.marketingcloudapis.com/Service.asmx'
                                  .format(config['tenant_subdomain']))

    # First try V1
    try:
        LOGGER.info('Trying to authenticate using V1 endpoint')
        params['useOAuth2Authentication'] = "False"
        auth_stub = FuelSDK.ET_Client(params=params)
        transport = HttpAuthenticated(timeout=int(config.get('request_timeout', 3600)))
        auth_stub.soap_client.set_options(
            transport=transport, timeout=3600)
        LOGGER.info("Success.")
        return auth_stub
    except Exception as e:
        LOGGER.info('Failed to auth using V1 endpoint')
        if not config.get('tenant_subdomain'):
            LOGGER.warning('No tenant_subdomain found, will not attempt to auth with V2 endpoint')
            raise e

    # Next try V2
    # Move to OAuth2: https://help.salesforce.com/articleView?id=mc_rn_january_2019_platform_ip_remove_legacy_package_create_ability.htm&type=5
    try:
        LOGGER.info('Trying to authenticate using V2 endpoint')
        params['useOAuth2Authentication'] = "True"
        params['authenticationurl'] = ('https://{}.auth.marketingcloudapis.com'
                                       .format(config['tenant_subdomain']))
        LOGGER.info("Authentication URL is: %s", params['authenticationurl'])
        auth_stub = FuelSDK.ET_Client(params=params)
        transport = HttpAuthenticated(timeout=int(config.get('request_timeout', 3600)))
        auth_stub.soap_client.set_options(
            transport=transport, timeout=3600)
    except Exception as e:
        LOGGER.info('Failed to auth using V2 endpoint')
        raise e

    LOGGER.info("Success.")
    return auth_stub
Exemple #9
0
    def __init__(self, con_opts):
        wsdl_url = 'file://%s/PeakflowSP.wsdl' % os.path.dirname(__file__)
        soap_url = 'https://%s/soap/sp' % con_opts.host

        # SOAP shit
        t = HttpAuthenticated(username=con_opts.username, password=con_opts.password)
        t.handler = urllib2.HTTPDigestAuthHandler(t.pm)
        t.urlopener = urllib2.build_opener(t.handler)
        self.client = Client(url = wsdl_url, location = soap_url, transport = t)

        self._timeout = 10
Exemple #10
0
    def __init__(self, con_opts):
        wsdl_url = 'file://%s/PeakflowSP.wsdl' % os.path.dirname(__file__)
        soap_url = 'https://%s/soap/sp' % con_opts.host

        # SOAP shit
        t = HttpAuthenticated(username=con_opts.username,
                              password=con_opts.password)
        t.handler = urllib2.HTTPDigestAuthHandler(t.pm)
        t.urlopener = urllib2.build_opener(t.handler)
        self.client = Client(url=wsdl_url, location=soap_url, transport=t)

        self._timeout = 10
Exemple #11
0
def get_service():
    global url
    global username
    global password

    wsdl_url = 'file://%s/PeakflowSP.wsdl' % os.getcwd()

    t = HttpAuthenticated(username=username, password=password)
    t.handler = urllib2.HTTPDigestAuthHandler(t.pm)
    t.urlopener = urllib2.build_opener(t.handler)

    client = Client(url=wsdl_url, location=url, transport=t)
    return client
Exemple #12
0
    def __init__(self, username, password, source='', wsdl_url=None, **kwargs):
        if not wsdl_url:
            wsdl_url = docmail.client.DOCMAIL_WSDL
        self.source = source
        self.username = username
        self.password = password

        self.return_format = 'XML'
        self.failure_return_format = 'XML'

        options = Options()
        options.transport = HttpAuthenticated()
        self.options = options
        options.cache = MemCache()
        self.set_options(**kwargs)
        reader = DefinitionsReader(options, Definitions)
        self.wsdl = reader.open(wsdl_url)
        plugins = PluginContainer(options.plugins)
        plugins.init.initialized(wsdl=self.wsdl)
        self.factory = Factory(self.wsdl)
        self.service = ServiceSelector(self, self.wsdl.services)
        self.sd = []
        for s in self.wsdl.services:
            sd = ServiceDefinition(self.wsdl, s)
            self.sd.append(sd)
        self.messages = dict(tx=None, rx=None)
Exemple #13
0
def connect_AXL():

  # First we connect to the AXL API
  # Logging for debugging
  logging.basicConfig(level=logging.INFO)
  #logging.getLogger('suds.client').setLevel(logging.DEBUG)
  logging.getLogger('suds.client').setLevel(logging.CRITICAL)
  #logging.getLogger('suds.transport').setLevel(logging.DEBUG)
  #logging.getLogger('suds.xsd.schema').setLevel(logging.CRITICAL)
  #logging.getLogger('suds.wsdl').setLevel(logging.CRITICAL)
  
  #"Connecting to myphone.central1.com to add the line and phones for the user"
  location = 'https://172.20.133.71:8443/axl/'
  if platform.uname()[0] == 'Darwin':
    # OSX path
    wsdl = 'file:///Users/fbobes/Documents/Python/CUCM/AXLAPI.wsdl'
  elif platform.uname()[0] == 'Linux':
    # Linux path
    wsdl = 'file:///home/fbobes/cucm/AXLAPI.wsdl'
  else: 
    # Some other OS
    wsdl = 'file:///home/fbobes/cucm/AXLAPI.wsdl'
  auth = getAuthentication("axl")  
  Username = auth[0]
  Password = auth[1]

  # Bypassing SSL self-cert check
  ssl._create_default_https_context = ssl._create_unverified_context

  # URL Detail
  client = Client(wsdl,location = location, transport = HttpAuthenticated(username = Username, password = Password),faults=False)

  return client
Exemple #14
0
    def add_client(self):

        logger.info('About to add a client to `%s` (%s)', self.address, self.conn_type)

        # Lazily-imported here to make sure gevent monkey patches everything well in advance
        from suds.client import Client
        from suds.transport.https import HttpAuthenticated
        from suds.transport.https import WindowsHttpAuthenticated
        from suds.wsse import Security, UsernameToken

        sec_type = self.config['sec_type']

        if sec_type == SEC_DEF_TYPE.BASIC_AUTH:
            transport = HttpAuthenticated(**self.suds_auth)

        elif sec_type == SEC_DEF_TYPE.NTLM:
            transport = WindowsHttpAuthenticated(**self.suds_auth)

        elif sec_type == SEC_DEF_TYPE.WSS:
            security = Security()
            token = UsernameToken(self.suds_auth['username'], self.suds_auth['password'])
            security.tokens.append(token)

            client = Client(self.address, autoblend=True, wsse=security)

        if sec_type in(SEC_DEF_TYPE.BASIC_AUTH, SEC_DEF_TYPE.NTLM):
            client = Client(self.address, autoblend=True, transport=transport)

        # Still could be either none at all or WSS
        if not sec_type:
            client = Client(self.address, autoblend=True, timeout=self.config['timeout'])

        self.client.put_client(client)
def new_client(service_type):
    """ Make a `suds` client, accounting for ?wsdl suffixes, failing to import appropriate schemas, and http auth

        Args:
            service_type: type of service to ping (usually 'procurement_service' or 'grant_service')

        Returns:
            Client for FSRS service
    """
    config = service_config(service_type)
    wsdl_url = config.get('wsdl', '')
    options = {'url': wsdl_url}

    if wsdl_url.endswith('?wsdl'):
        options['location'] = wsdl_url[:-len('?wsdl')]

    # The WSDL is missing an import; it's so common that suds has a work around
    parsed_wsdl = urlparse(wsdl_url)
    import_fix = doctor.Import('http://schemas.xmlsoap.org/soap/encoding/')
    # Main namespace is the wsdl domain
    import_fix.filter.add('{}://{}/'.format(parsed_wsdl.scheme, parsed_wsdl.netloc))

    options['doctor'] = doctor.ImportDoctor(import_fix)
    options['plugins'] = [ControlFilter(), ZeroDateFilter()]

    if config.get('username') and config.get('password'):
        options['transport'] = HttpAuthenticated(
            username=config['username'],
            password=config['password'],
            timeout=300)

    return Client(**options)
Exemple #16
0
def get_auth_stub(config):
    """
    Given a config dict in the format:

        {'clientid': ... your ET client ID ...,
         'clientsecret': ... your ET client secret ...}

    ... return an auth stub to be used when making requests.
    """
    LOGGER.info("Generating auth stub...")

    params = {
        'clientid': config['client_id'],
        'clientsecret': config['client_secret']
    }

    if config.get('tenant_subdomain'):
        # For S10+ accounts: https://developer.salesforce.com/docs/atlas.en-us.noversion.mc-apis.meta/mc-apis/your-subdomain-tenant-specific-endpoints.htm
        params['authenticationurl'] = (
            'https://{}.auth.marketingcloudapis.com/v1/requestToken'.format(
                config['tenant_subdomain']))
        params['soapendpoint'] = (
            'https://{}.soap.marketingcloudapis.com/Service.asmx'.format(
                config['tenant_subdomain']))

    auth_stub = FuelSDK.ET_Client(params=params)
    transport = HttpAuthenticated(
        timeout=int(config.get('request_timeout', 900)))
    auth_stub.soap_client.set_options(transport=transport)

    LOGGER.info("Success.")

    return auth_stub
Exemple #17
0
            def add_client():

                sec_type = self.config['sec_type']

                if sec_type == security_def_type.basic_auth:
                    transport = HttpAuthenticated(**self.suds_auth)

                elif sec_type == security_def_type.ntlm:
                    transport = WindowsHttpAuthenticated(**self.suds_auth)

                elif sec_type == security_def_type.wss:
                    security = Security()
                    token = UsernameToken(self.suds_auth['username'],
                                          self.suds_auth['password'])
                    security.tokens.append(token)

                    client = Client(url, autoblend=True, wsse=security)

                if sec_type in (security_def_type.basic_auth,
                                security_def_type.ntlm):
                    client = Client(url, autoblend=True, transport=transport)

                # Still could be either none at all or WSS
                if not sec_type:
                    client = Client(url, autoblend=True)

                self.client.queue.put(client)
                logger.debug('Adding Suds SOAP client to [%s]', url)
    def preProcess(self, _edObject=None):
        EDPluginControl.preProcess(self)

        # Initializing webservices
        self.DEBUG("EDPluginBioSaxsISPyBModellingv1_0.preProcess")
        self.dataBioSaxsSample = self.dataInput.sample

        user = None
        password = ""
        if self.dataBioSaxsSample:
            if self.dataBioSaxsSample.login:
                user = self.dataBioSaxsSample.login.value
                password = self.dataBioSaxsSample.passwd.value
                self.URL = self.dataBioSaxsSample.ispybURL
        if not user:
            self.ERROR(
                "No login/password information in sample configuration. Giving up."
            )
            self.setFailure()
            return
#         self.modellingResult = self.dataInput.saxsModelingResult
        if "http:" in self.URL:
            #print "OLD URL"
            self.URL = self.URL.replace("http:", "https:", 1)

            self.URL = self.URL.replace("8080", "", 1)
        # I don't trust in this authentication.... but it is going to work soon
        self.httpAuthenticatedToolsForBiosaxsWebService = HttpAuthenticated(
            username=user, password=password)
        self.client = Client(
            self.dataBioSaxsSample.ispybURL.value,
            transport=self.httpAuthenticatedToolsForBiosaxsWebService,
            cache=None)
Exemple #19
0
 def _create_basic_auth(self):
     """
     Create the Basic auth
     """
     basic = HttpAuthenticated(username=self.username,
                               password=self.password)
     return basic
def get_device_ip(phone_name):

    #Disable HTTPS certificate validation check - not recommended for production
    if hasattr(ssl, '_create_unverified_context'):
        ssl._create_default_https_context = ssl._create_unverified_context

    url = 'https://' + user_env.CUCM_LOCATION + ':8443/realtimeservice/services/RisPort?wsdl'
    print(url)

    tns = 'http://schemas.cisco.com/ast/soap/'
    imp = Import('http://schemas.xmlsoap.org/soap/encoding/',
                 'http://schemas.xmlsoap.org/soap/encoding/')
    imp.filter.add(tns)

    t = HttpAuthenticated(username=user_env.CUCM_USER,
                          password=user_env.CUCM_PASSWORD)
    t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)

    context = ssl.SSLContext()

    t1 = urllib.request.HTTPSHandler(context=context)
    t.urlopener = urllib.request.build_opener(t.handler, t1)

    c = Client(url, plugins=[ImportDoctor(imp)], transport=t)

    result = c.service.SelectCmDevice('', {
        'SelectBy': 'Name',
        'Status': 'Any',
        'Class': 'Phone'
    })

    total_phones = result['SelectCmDeviceResult']['TotalDevicesFound']
    list_phones = result['SelectCmDeviceResult']["CmNodes"]
    print('number of devices found', total_phones)

    for node in result['SelectCmDeviceResult']['CmNodes']:
        for device in node['CmDevices']:
            if device["IpAddress"] is None:
                print("IP address not assigned for", device["Name"])
                print("----------------")
                continue
            else:
                print("Name ", device["Name"], "IP Address: ",
                      device["IpAddress"])
                print("----------------")
                continue
Exemple #21
0
    def send(self, request):
        self.addenhanceddnsheaders(request)

        response = HttpAuthenticated.send(self, request)

        self.logenhanceddnsheaders(response)

        return response
Exemple #22
0
    def init_suds_lib(self, url):
        from suds.client import Client
        from suds.transport.https import HttpAuthenticated
        credentials = dict(username=tambov_api_login,
                           password=tambov_api_password)
        transport_with_basic_auth = HttpAuthenticated(**credentials)

        self.client = Client(url, transport=transport_with_basic_auth)
Exemple #23
0
    def send(self, request):
        self.addenhanceddnsheaders(request)

        response = HttpAuthenticated.send(self, request)

        self.logenhanceddnsheaders(response)

        return response
Exemple #24
0
 def __init__(self, wsdl, settings):
     transport = HttpAuthenticated(username=settings.get('username'),
                                   password=settings.get('password'),
                                   timeout=DEFAULT_CLIENT_TIMEOUT)
     self.client = Client(wsdl,
                          cache=SudsCache(),
                          transport=transport,
                          location=re.sub(r'\?wsdl$', '', wsdl))
Exemple #25
0
    def __init__(
            self,
            host=cfg.cucm_host,
            username=cfg.cucm_user,
            password=cfg.cucm_pass,
            timeout=30):

        self.host = host
        self.username = username
        self.password = password
        wsdl = 'https://' + host + \
            ':8443/controlcenterservice2/services/ControlCenterServices?wsdl'
        location = 'https://' + host + \
            ':8443/controlcenterservice2/services/ControlCenterServices'
        TNS = 'http://schemas.cisco.com/ast/soap'
        IMP = Import('http://schemas.xmlsoap.org/soap/encoding/')
        IMP.filter.add(TNS)

        t = HttpAuthenticated(username=self.username,
                              password=self.password, timeout=timeout)
        t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)

        ssl_def_context = ssl.create_default_context()
        ssl_def_context.check_hostname = False
        ssl_def_context.verify_mode = ssl.CERT_NONE

        t1 = urllib.request.HTTPSHandler(context=ssl_def_context)
        t.urlopener = urllib.request.build_opener(t.handler, t1)

        class SetPrefix(MessagePlugin):

            def marshalled(self,
                           context):
                context.envelope[1][0][0].setPrefix('soap')

        self.client = Client(
            wsdl,
            location=location,
            username=username,
            password=password,
            cache=None,
            timeout=timeout,
            plugins=[ImportDoctor(IMP), SetPrefix()],
            transport=t
        )
    def __init__(
        self,
        host=cfg.cucm_host,
        username=cfg.cucm_user,
        password=cfg.cucm_pass,
        cucm_version=cfg.cucm_version,
        timeout=10,
        wsdl="file://" +
            os.path.abspath(
                "axl_wsdl/{0}/AXLAPI.wsdl".format(cfg.cucm_version)),
    ):

        self.username = username
        self.password = password
        self.wsdl = wsdl
        self.host = host
        self.timeout = timeout

        t = HttpAuthenticated(username=self.username,
                              password=self.password, timeout=timeout)
        t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)

        ses = urllib.request.HTTPCookieProcessor()

        ssl_def_context = ssl.create_default_context()
        ssl_def_context.check_hostname = False
        ssl_def_context.verify_mode = ssl.CERT_NONE

        t1 = urllib.request.HTTPSHandler(context=ssl_def_context)
        t.urlopener = urllib.request.build_opener(t.handler, t1, ses)

        tns = 'http://schemas.cisco.com/ast/soap/'
        imp = Import('http://schemas.xmlsoap.org/soap/encoding/',
                     'http://schemas.xmlsoap.org/soap/encoding/')
        imp.filter.add(tns)

        self.client = Client(
            self.wsdl,
            location='https://{0}:8443/axl/'.format(host),
            faults=False,
            plugins=[ImportDoctor(imp)],
            transport=t
        )

        self.service = self.client.service
    def u2handlers(self):
        handlers = HttpAuthenticated.u2handlers(self)

        context = ssl._create_unverified_context()

        # add an HTTPS handler, using the custom context
        handlers.append(HTTPSHandler(context=context))

        return handlers
Exemple #28
0
    def u2handlers(self):
        # use handlers from superclass
        handlers = HttpAuthenticated.u2handlers(self)
        # create custom ssl context, e.g.
        ctx = ssl.create_default_context(cafile=CERTIFICATE_LOCATION)
        # configure context as needed...
        ctx.check_hostname = False

        # add a https handler using the custom context
        handlers.append(HTTPSHandler(context=ctx))
        return handlers
    def __init__(self, cert, verify=True, **kwargs):
        """
        Initialisation.

        Args:
            cert (tuple): Tuple containing the path to the cert file followed
                          by the path to the key file as strings.
            verify (bool/str): Whether to verify the handled request url. If a
                               string is given then this is used as the path to
                               a CA_BUNDLE file or directory with certificates of
                               trusted CAs. Note: If verify is set to a path to a
                               directory, the directory must have been processed
                               using the c_rehash utility supplied with OpenSSL.
                               This list of trusted CAs can also be specified through
                               the REQUESTS_CA_BUNDLE environment variable (this may
                               cause pip to fail to validate against PyPI).
        """
        HttpAuthenticated.__init__(self, **kwargs)
        self.cert = cert
        self.verify = verify
Exemple #30
0
def setup_connection():

    home = expanduser("~")
    credentials = os.path.join(home, 'scheduling.ini')

    cf = ConfigParser.ConfigParser()
    cf.read(credentials)
    username = cf.get('credentials', 'username')
    password = cf.get('credentials', 'password')
    beamline = cf.get('settings', 'beamline')

    # Uncomment one if using ANL INTERNAL or EXTERNAL network
    #base = cf.get('hosts', 'internal')
    base = cf.get('hosts', 'external')

    result = urllib2.install_opener(urllib2.build_opener(HTTPSHandlerV3()))
    logging.raiseExceptions = 0

    beamlineScheduleServiceURL = base + \
        'beamlineScheduleService/beamlineScheduleWebService.wsdl'

    runScheduleServiceURL = base + \
        'runScheduleService/runScheduleWebService.wsdl'

    try:
        credentials = dict(username=username, password=password)
        t = HttpAuthenticated(**credentials)
        if debug:
            print t.u2handlers()
            print t.credentials()
        runScheduleServiceClient = Client(runScheduleServiceURL)
        runScheduleServiceClient.options.cache.setduration(seconds=10)
        result = setSoapHeader(runScheduleServiceClient, username, password)
        beamlineScheduleServiceClient = Client(beamlineScheduleServiceURL)
        beamlineScheduleServiceClient.options.cache.setduration(seconds=10)
        result = setSoapHeader(
            beamlineScheduleServiceClient, username, password)
    except Exception, ex:
        print "CANNOT OPEN SERVICES:" + str(ex)
        raise
        exit(-1)
Exemple #31
0
    def __init__(self, username, password, wsdl, cucm, cucm_version):
        """
        :param username: axl username
        :param password: axl password
        :param wsdl: wsdl file location
        :param cucm: UCM IP address
        :param cucm_version: UCM version

        example usage:
        >>> from axl.foley import AXL
        >>> wsdl = 'file:///path/to/wsdl/axlsqltoolkit/schema/10.5/AXLAPI.wsdl'
        >>> ucm = AXL('axl_user', 'axl_pass' wsdl, '192.168.200.10')
        """
        self.username = username
        self.password = password
        self.wsdl = wsdl
        self.cucm = cucm
        self.cucm_version = cucm_version

        tns = 'http://schemas.cisco.com/ast/soap/'
        imp = Import('http://schemas.xmlsoap.org/soap/encoding/',
                     'http://schemas.xmlsoap.org/soap/encoding/')
        imp.filter.add(tns)

        t = HttpAuthenticated(username=self.username, password=self.password)
        t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)

        ssl_def_context = ssl.create_default_context()
        ssl_def_context.check_hostname = False
        ssl_def_context.verify_mode = ssl.CERT_NONE
        if float(cucm_version) <= 8.5:
            ssl_def_context.set_ciphers('HIGH:!DH:!aNULL')

        t1 = urllib.request.HTTPSHandler(context=ssl_def_context)
        t.urlopener = urllib.request.build_opener(t.handler, t1)

        self.client = Client(self.wsdl,
                             location='https://{0}:8443/axl/'.format(cucm),
                             faults=False,
                             plugins=[ImportDoctor(imp)],
                             transport=t)
Exemple #32
0
 def getPendingNotificationDetails(self, request_id, debug=False):
     authenticated = HttpAuthenticated(username=self.getUserId(),
                                       password=self.getPassword())
     result = suds.client.Client(
         url=self.getProperty("tracking_url_string"),
         transport=authenticated).service.getPendingNotificationDetails(
             request_id)
     return {
         "status": str(result.status),
         "notification_status": str(result.notificationStatus),
         "detail": repr(result)
     }
Exemple #33
0
    def _access_code_method_(self,
                             request,
                             action,
                             access_code='',
                             is_post=True):
        result = None
        if self.method == 'SOAP':

            if self.debug:
                logging.basicConfig(level=logging.DEBUG)
                logging.getLogger('suds.client').setLevel(logging.DEBUG)
            else:
                logging.basicConfig(level=logging.INFO)
                logging.getLogger('suds.client').setLevel(logging.INFO)

            # Create AUTH credentials
            credentials = dict(username=self.username, password=self.password)
            t = HttpAuthenticated(**credentials)

            # Read WSDL
            wsdl_url = '%s?WSDL' % self.url['SOAP']
            client = Client(wsdl_url, transport=t)

            # Send request
            if action == 'CREATE':
                result = client.service.CreateAccessCode(request)
            else:
                result = client.service.GetAccessCodeResult(request)

        elif self.method == 'REST':
            # Create URL for REST
            rest_url = self.url['REST']
            rest_url += 's' if action == 'CREATE' else '/%s' % str(access_code)
            result = self.__post_to_rapidapi__(rest_url, request, is_post)

        elif self.method == 'POST':
            is_post = True
            if self.format == 'XML':
                result = self.__post_to_rapidapi__(
                    self.url['POST']['XML'][action], request, is_post)
            else:
                result = self.__post_to_rapidapi__(
                    self.url['POST']['JSON'][action], request, is_post)

        elif self.method == 'RPC':
            if self.format == 'XML':
                result = self.__post_to_rapidapi__(self.url['RPC']['XML'],
                                                   request, is_post)
            else:
                result = self.__post_to_rapidapi__(self.url['RPC']['JSON'],
                                                   request, is_post)

        return result
def risport_request():
    phone_list = []

    #Disable HTTPS certificate validation check - not recommended for production
    if hasattr(ssl, '_create_unverified_context'):
        ssl._create_default_https_context = ssl._create_unverified_context

    url = 'https://' + user_env.CUCM_LOCATION + ':8443/realtimeservice/services/RisPort?wsdl'

    tns = 'http://schemas.cisco.com/ast/soap/'
    imp = Import('http://schemas.xmlsoap.org/soap/encoding/',
                 'http://schemas.xmlsoap.org/soap/encoding/')
    imp.filter.add(tns)

    t = HttpAuthenticated(username=user_env.CUCM_USER,
                          password=user_env.CUCM_PASSWORD)
    t.handler = urllib.request.HTTPBasicAuthHandler(t.pm)

    context = ssl.SSLContext()

    t1 = urllib.request.HTTPSHandler(context=context)
    t.urlopener = urllib.request.build_opener(t.handler, t1)

    c = Client(url, plugins=[ImportDoctor(imp)], transport=t)

    result = c.service.SelectCmDevice('', {
        'SelectBy': 'Name',
        'Status': 'Any',
        'Class': 'Phone'
    })

    total_phones = result['SelectCmDeviceResult']['TotalDevicesFound']

    list_phones = result['SelectCmDeviceResult']["CmNodes"]

    for node in result['SelectCmDeviceResult']['CmNodes']:
        for device in node['CmDevices']:
            phone_list.append(device)

    return phone_list
Exemple #35
0
def soap_client():
    """ SoapClient to EVM based on base_url"""
    username = conf.credentials['default']['username']
    password = conf.credentials['default']['password']
    url = '{}/vmdbws/wsdl/'.format(store.base_url)

    transport = HttpAuthenticated(username=username, password=password)
    imp = Import('http://schemas.xmlsoap.org/soap/encoding/')
    doc = ImportDoctor(imp)

    client = MiqClient(url, transport=transport, doctor=doc)

    return client
Exemple #36
0
def getTransport():
    transport = None
    logger = UtilsLogging.getLogger()
    if not "ISPyB_user" in os.environ:
        logger.error("No ISPyB user name defined as environment variable!")
    elif not "ISPyB_pass" in os.environ:
        logger.error("No ISPyB password defined as environment variable!")
    else:
        ispybUserName = os.environ["ISPyB_user"]
        ispybPassword = os.environ["ISPyB_pass"]
        transport = HttpAuthenticated(username=ispybUserName,
                                      password=ispybPassword)
    return transport
    def __createClient(self, ciType):
        "@types: str -> suds.Client"
        credentials = dict(username=self.__connectionDataManager.getUsername(),
                           password=self.__connectionDataManager.getPassword())

        proxy = self.__connectionDataManager.getProxy()
        if proxy:
            credentials['proxy'] = {'http': proxy, 'https': proxy}

        t = HttpAuthenticated(**credentials)
        url = '%s/%s.do?displayvalue=all&wsdl' % (
            self.__connectionDataManager.getConnectionUrl(), ciType)
        return Client(url, transport=t, cache=None)
Exemple #38
0
 def u2handlers(self):
     handlers = HttpAuthenticated.u2handlers(self)
     handlers.append(HTTPSHandlerNoVerify())
     return handlers
 def __init__(self,*args,**kwargs):
   HttpAuthenticated.__init__(self,*args,**kwargs)
   self.last_headers = None
Exemple #40
0
    def __init__(self, **kwargs):

        self.cert = kwargs.pop('cert', None)
        HttpAuthenticated.__init__(self, **kwargs)
 def send(self,request):
   result = HttpAuthenticated.send(self,request)
   self.last_headers = result.headers
   return result
 def u2handlers(self):
   handlers = [ urllib2.HTTPSHandler(context=ssl._create_unverified_context()) ]
   handlers.extend(HttpAuthenticated.u2handlers(self))
   return handlers
Exemple #43
0
 def __init__(self, cert, **kwargs):
     self.cert = cert
     # super won't work because not using new style class
     HttpAuthenticated.__init__(self, **kwargs)