def connect():
global client
cs = ClientSettings("myClient", [server_address])
# Uncomment below for session logging
# cs.logToStdOutLevel = loglevels.Info
max_attempts = 40
num_attempts = 0
while (True):
print "Trying to connect to the OPC UA Server. Attempt #" + str(
num_attempts)
result = None
try:
client = Client(cs)
rootNode = Address(NodeId(opcuaidentifiers.OpcUaId_RootFolder, 0),
server_uri)
result = client.browse([rootNode])
except Exception as e:
print "Got exception: " + str(e)
num_attempts = num_attempts + 1
if num_attempts > max_attempts:
msg = 'Despite ' + str(
max_attempts
) + ' attempts couldnt establish OPC UA connection: exception is ' + str(
e)
print msg
dcs_test_utils.log_detail(False, msg, '')
raise msg
time.sleep(3)
continue
print 'Connected to OPC UA Server'
return
def connect(endpoint, server_uri):
client_settings = ClientSettings("pnikiel:dump", [endpoint])
client = Client(client_settings)
connectionId = client.manuallyConnect(server_uri)
sessionInfo = client.sessionInformation(connectionId)
if sessionInfo.sessionState != pyuaf.client.sessionstates.Connected:
raise Exception('Couldnt connect! TODO: reason')
print 'Connected to ' + endpoint
return (client, connectionId)
from pyuaf.util.errors import UafError
# define the namespace URI and server URI of the UaServerCPP demo server
demoServerUri = "urn:UnifiedAutomation:UaServerCpp"
# define the address of the Root node which we would like to start browsing
rootNode = Address(NodeId(opcuaidentifiers.OpcUaId_RootFolder, 0),
demoServerUri)
# define the ClientSettings:
settings = ClientSettings()
settings.applicationName = "MyClient"
settings.discoveryUrls.append("opc.tcp://localhost:48010")
# create the client
myClient = Client(settings)
try:
print("")
print("First option: use the convenience function \"browse()\"")
print("===================================================")
# now browse the root node
# (notice that there is also an argument called 'maxAutoBrowseNext', which we don't mention
# here because we can leave it at the default value (100), to make sure that BrowseNext is
# automatically being called for us as much as needed!)
# (notice too that you can optionally provide a BrowseConfig and a SessionConfig for
# more detailed configuration)
firstLevelBrowseResult = myClient.browse([rootNode])
# print the result
# We configure the PKI folder structure (set the PKI_FOLDER to 'PKI' and you get the defaults).
# Note that paths must ALWAYS be specified using '/', also on Windows!
# You cannot use os.path.join or similar, since these will introduce platform-dependent separators!
clientSettings.clientCertificate = PKI_FOLDER + '/client/certs/client.der'
clientSettings.clientPrivateKey = PKI_FOLDER + '/client/private/client.pem'
clientSettings.certificateTrustListLocation = PKI_FOLDER + '/trusted/certs/'
clientSettings.certificateRevocationListLocation = PKI_FOLDER + '/trusted/crl/'
clientSettings.issuersCertificatesLocation = PKI_FOLDER + '/issuers/certs/'
clientSettings.issuersRevocationListLocation = PKI_FOLDER + '/issuers/crl/'
# make sure the above directories are created
clientSettings.createSecurityLocations()
# create the client
myClient = Client(clientSettings)
print("")
print(
"==========================================================================================="
)
print("STEP 3: Store the client certificate and private key")
print(
"==========================================================================================="
)
print("")
# store the certificate
result = certificate.toDERFile(clientSettings.clientCertificate)
if result == -1:
raise Exception("Could not save the client certificate!")
logDetailsString = ""
logDetailsString += time.strftime("%a, %d %b %Y %H:%M:%S",
time.localtime(msg.ctime))
logDetailsString += ".%.3d " % msg.msec
logDetailsString += "%-10s " % msg.applicationName
logDetailsString += "%-20s " % msg.loggerName
logDetailsString += "%-8s " % loglevels.toString(msg.level)
# msg.message may contain multiple lines, so we prepend the other logging details in
# front of each line:
for line in msg.message.splitlines():
f.write("%s: %s\n" % (logDetailsString, line))
# Example 0: create a client with the default settings and no logging callback
# --------------------------------------------------------------------------------------------------
client0 = Client()
# Example 1: create a client by specifying the settings
# --------------------------------------------------------------------------------------------------
client1 = Client(settings)
# Example 2: create a client by specifying the settings
# --------------------------------------------------------------------------------------------------
client2 = Client(settings, callback)
# Example 3: create a client by specifying only the logging callback
# --------------------------------------------------------------------------------------------------
client3 = Client(loggingCallback=callback)
# you can still provide settings and register a logging callback afterwards, but you'll need to use:
# client0.setClientSettings(settings)
from pyuaf.client import Client
from pyuaf.client.settings import ClientSettings, SessionSettings
from pyuaf.util import Address, NodeId, opcuaidentifiers
import uao
server_uri = 'urn:CERN:QuasarOpcUaServer' # needs to match the factual server URI
server_address = 'opc.tcp://127.0.0.1:4841'
cs = ClientSettings("myClient", [server_address])
client = Client(cs)
# next 2 lines are not necessary but help to ensure good state of OPC-UA connectivity
rootNode = Address(NodeId(opcuaidentifiers.OpcUaId_RootFolder, 0), server_uri)
result = client.browse([rootNode])
session = uao.Session(client, server_uri)
obj = session.get_object('anObject',
2) # needs to match factuall existing object
# examples/pyuaf/client/easiest_client_example.py
# Start the demo server ($SDK/bin/uaservercpp) of Unified Automation before running this script!
import pyuaf
from pyuaf.util import Address, NodeId
from pyuaf.client import Client
from pyuaf.client.settings import ClientSettings
# create a client named "myClient", and provide the discovery URL of the server (uaservercpp):
myClient = Client(ClientSettings("myClient", ["opc.tcp://localhost:48010"]))
# specify the address of the node of which we would like to read its Value attribute:
# (here we're using an absolute address, i.e. a NodeId(<identifier>, <namespace URI>) and a <server URI>)
someAddress = Address(
NodeId(
"Demo.SimulationSpeed", # NodeId identifier
"http://www.unifiedautomation.com/DemoServer"), # NodeId namespace URI
"urn:UnifiedAutomation:UaServerCpp") # server URI
# read the Value attribute of the node that we just addressed:
result = myClient.read([someAddress])
print("The value is %d" % result.targets[0].data.value)
# every 20 seconds (configurable, see above) the URLs you provided, and keep an inventory of all discovered
# endpoints. If at some point the UAF thinks it's necessary to connect to one of these servers (e.g. because
# you want to read a variable on a particular server), it will automatically create the necessary session
# for you.
# -> Bottomline: just provide the discovery URLs to the UAF, and afterwards you can directly start
# reading data or monitoring events or calling methods or whatever. No need to manage connections yourself!
# -> All OPC UA servers have such a Discovery endpoint, but additionally there are also "dedicated" discovery servers
# that do nothing more than provide endpoints to other servers. Most people will never have to deal with such a
# server, however.
# -> In the (advanced!) scenario where a hierarchy of dedicated discovery servers is used, you only need to specify
# the top discovery server. The UAF will automatically discover the discovery servers that are lower in the
# hierarchy.
# create the client
myClient = Client(myClientSettings)
print("")
print("################################################################################################################")
print("Step 3: Specify the addresses to some nodes which we would like to read/write/browse/monitor/call/...")
print("################################################################################################################")
print("")
# There are *many* ways how you can identify (address) a node, see the examples below:
# 1) absolute address to the standard OPC UA "RootFolder" node (notice the standard OPC UA index 0)
# 2) absolute address to the non-standard "Demo" node (notice the demo server namespace URI)
# 3) absolute address to the non-standard "BoilerDemo" node (notice that we use an ExpandedNodeId this time)
# 4) relative address to the "Boiler1" node (relative to the previous address)
def connect( ):
global client
cs = ClientSettings("myClient", [server_address])
client = Client(cs)
rootNode = Address( NodeId(opcuaidentifiers.OpcUaId_RootFolder, 0), server_uri )
result=client.browse ([ rootNode ])
settings.applicationName = "myClient"
settings.logToStdOutLevel = loglevels.Debug
settings.logToCallbackLevel = loglevels.Error
# define the callback for the logging
def myLoggingCallback(msg):
print("************ CALLBACK SAYS: ************")
if msg.level == loglevels.Error:
print("Error message received: %s" % str(msg))
elif msg.level == loglevels.Warning:
print("Warning message received: %s" % str(msg))
else:
print("Info or debug message received: %s" % str(msg))
# create the client
myClient = Client(settings, myLoggingCallback)
# try to read the Value attribute of some non-existing node (so errors will be sent to the callback)
try:
nodeId = NodeId("NonExistingIdentifier", "NonExistingNameSpace")
address = Address(nodeId, "NonExistingServerURI")
myClient.read([address])
except pyuaf.util.errors.UafError, e:
print("UAF error raised: %s" % e)
# alternatively:
myClient2 = Client()
myClient2.registerLoggingCallback(myLoggingCallback)
myClient2.setClientSettings(settings)
