| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| # |
| |
| from uuid import UUID |
| |
| from org.apache.qpid.proton.engine import EndpointState, TransportException, Sasl, SslDomain |
| from org.apache.qpid.proton.engine.impl import ConnectionImpl, SessionImpl, \ |
| SenderImpl, ReceiverImpl, TransportImpl |
| from org.apache.qpid.proton.engine.impl.ssl import SslDomainImpl, SslPeerDetailsImpl |
| from org.apache.qpid.proton.message import MessageFormat |
| from org.apache.qpid.proton.message.impl import MessageImpl |
| from org.apache.qpid.proton.messenger import MessengerException, Status |
| from org.apache.qpid.proton.messenger.impl import MessengerImpl |
| from org.apache.qpid.proton.amqp.messaging import Source, Target, Accepted, AmqpValue |
| from org.apache.qpid.proton.amqp import UnsignedInteger |
| from jarray import zeros |
| from java.util import EnumSet, UUID as JUUID |
| from java.util.concurrent import TimeoutException as Timeout |
| |
| LANGUAGE = "Java" |
| |
| class Skipped(Exception): |
| skipped = True |
| |
| PN_SESSION_WINDOW = TransportImpl.SESSION_WINDOW |
| |
| PENDING = "PENDING" |
| ACCEPTED = "ACCEPTED" |
| REJECTED = "REJECTED" |
| |
| STATUSES = { |
| Status.ACCEPTED: ACCEPTED, |
| Status.REJECTED: REJECTED, |
| Status.PENDING: PENDING, |
| Status.UNKNOWN: None |
| } |
| |
| MANUAL = "MANUAL" |
| AUTOMATIC = "AUTOMATIC" |
| |
| class Endpoint(object): |
| |
| LOCAL_UNINIT = 1 |
| LOCAL_ACTIVE = 2 |
| LOCAL_CLOSED = 4 |
| REMOTE_UNINIT = 8 |
| REMOTE_ACTIVE = 16 |
| REMOTE_CLOSED = 32 |
| |
| def __init__(self): |
| self.condition = None |
| |
| @property |
| def remote_condition(self): |
| raise Skipped() |
| |
| @property |
| def state(self): |
| local = self.impl.getLocalState() |
| remote = self.impl.getRemoteState() |
| |
| result = 0 |
| |
| if (local == EndpointState.UNINITIALIZED): |
| result = result | self.LOCAL_UNINIT |
| elif (local == EndpointState.ACTIVE): |
| result = result | self.LOCAL_ACTIVE |
| elif (local == EndpointState.CLOSED): |
| result = result | self.LOCAL_CLOSED |
| |
| if (remote == EndpointState.UNINITIALIZED): |
| result = result | self.REMOTE_UNINIT |
| elif (remote == EndpointState.ACTIVE): |
| result = result | self.REMOTE_ACTIVE |
| elif (remote == EndpointState.CLOSED): |
| result = result | self.REMOTE_CLOSED |
| |
| return result |
| |
| def _enums(self, mask): |
| local = [] |
| if (self.LOCAL_UNINIT | mask): |
| local.append(EndpointState.UNINITIALIZED) |
| if (self.LOCAL_ACTIVE | mask): |
| local.append(EndpointState.ACTIVE) |
| if (self.LOCAL_CLOSED | mask): |
| local.append(EndpointState.CLOSED) |
| |
| remote = [] |
| if (self.REMOTE_UNINIT | mask): |
| remote.append(EndpointState.UNINITIALIZED) |
| if (self.REMOTE_ACTIVE | mask): |
| remote.append(EndpointState.ACTIVE) |
| if (self.REMOTE_CLOSED | mask): |
| remote.append(EndpointState.CLOSED) |
| |
| return EnumSet.of(*local), EnumSet.of(*remote) |
| |
| |
| def open(self): |
| self.impl.open() |
| |
| def close(self): |
| self.impl.close() |
| |
| class Condition: |
| |
| def __init__(self, name, description=None, info=None): |
| self.name = name |
| self.description = description |
| self.info = info |
| |
| def __repr__(self): |
| return "Condition(%s)" % ", ".join([repr(x) for x in |
| (self.name, self.description, self.info) |
| if x]) |
| |
| def __eq__(self, o): |
| if not isinstance(o, Condition): return False |
| return self.name == o.name and \ |
| self.description == o.description and \ |
| self.info == o.info |
| |
| def wrap_connection(impl): |
| if impl: return Connection(_impl = impl) |
| |
| class Connection(Endpoint): |
| |
| def __init__(self, _impl=None): |
| self.impl = _impl or ConnectionImpl() |
| |
| @property |
| def writable(self): |
| raise Skipped() |
| |
| def session(self): |
| return wrap_session(self.impl.session()) |
| |
| def session_head(self, mask): |
| return wrap_session(self.impl.sessionHead(*self._enums(mask))) |
| |
| def link_head(self, mask): |
| return wrap_link(self.impl.linkHead(*self._enums(mask))) |
| |
| @property |
| def work_head(self): |
| return wrap_delivery(self.impl.getWorkHead()) |
| |
| def _get_container(self): |
| return self.impl.getContainer() |
| def _set_container(self, container): |
| self.impl.setContainer(container) |
| container = property(_get_container, _set_container) |
| |
| |
| def _get_hostname(self): |
| return self.impl.getHostname() |
| def _set_hostname(self, hostname): |
| self.impl.setHostname(hostname) |
| hostname = property(_get_hostname, _set_hostname) |
| |
| def _get_remote_container(self): |
| return self.impl.getRemoteContainer() |
| def _set_remote_container(self, container): |
| self.impl.setRemoteContainer(container) |
| remote_container = property(_get_remote_container, _set_remote_container) |
| |
| |
| def _get_remote_hostname(self): |
| return self.impl.getRemoteHostname() |
| def _set_remote_hostname(self, hostname): |
| self.impl.setRemoteHostname(hostname) |
| remote_hostname = property(_get_remote_hostname, _set_remote_hostname) |
| |
| @property |
| def offered_capabilities(self): |
| return DataDummy() |
| |
| |
| def wrap_session(impl): |
| # XXX |
| if impl: return Session(impl) |
| |
| class Session(Endpoint): |
| |
| def __init__(self, impl): |
| self.impl = impl |
| |
| @property |
| def connection(self): |
| return wrap_connection(self.impl.getConnection()) |
| |
| def sender(self, name): |
| return wrap_link(self.impl.sender(name)) |
| |
| def receiver(self, name): |
| return wrap_link(self.impl.receiver(name)) |
| |
| def wrap_link(impl): |
| if impl is None: return None |
| elif isinstance(impl, SenderImpl): |
| return Sender(impl) |
| elif isinstance(impl, ReceiverImpl): |
| return Receiver(impl) |
| else: |
| raise Exception("unknown type") |
| |
| class Link(Endpoint): |
| |
| def __init__(self, impl): |
| self.impl = impl |
| |
| @property |
| def source(self): |
| if self.impl.getSource() is None: |
| self.impl.setSource(Source()) |
| return Terminus(self.impl.getSource()) |
| |
| @property |
| def target(self): |
| if self.impl.getTarget() is None: |
| self.impl.setTarget(Target()) |
| return Terminus(self.impl.getTarget()) |
| |
| @property |
| def remote_source(self): |
| return Terminus(self.impl.getRemoteSource()) |
| @property |
| def remote_target(self): |
| return Terminus(self.impl.getRemoteTarget()) |
| |
| @property |
| def session(self): |
| return wrap_session(self.impl.getSession()) |
| |
| def delivery(self, tag): |
| return wrap_delivery(self.impl.delivery(tag)) |
| |
| @property |
| def current(self): |
| return wrap_delivery(self.impl.current()) |
| |
| def advance(self): |
| return self.impl.advance() |
| |
| @property |
| def unsettled(self): |
| return self.impl.getUnsettled() |
| |
| @property |
| def credit(self): |
| return self.impl.getCredit() |
| |
| @property |
| def available(self): |
| raise Skipped() |
| |
| @property |
| def queued(self): |
| return self.impl.getQueued() |
| |
| def next(self, mask): |
| return wrap_link(self.impl.next(*self._enums(mask))) |
| |
| class DataDummy: |
| |
| def format(self): |
| pass |
| |
| def put_array(self, *args, **kwargs): |
| raise Skipped() |
| |
| class Terminus(object): |
| |
| UNSPECIFIED = None |
| |
| def __init__(self, impl): |
| self.impl = impl |
| self.type = None |
| self.timeout = None |
| self.durability = None |
| self.expiry_policy = None |
| self.dynamic = None |
| self.properties = DataDummy() |
| self.outcomes = DataDummy() |
| self.filter = DataDummy() |
| self.capabilities = DataDummy() |
| |
| def _get_address(self): |
| return self.impl.getAddress() |
| def _set_address(self, address): |
| self.impl.setAddress(address) |
| address = property(_get_address, _set_address) |
| |
| def _get_timeout(self): |
| return self.impl.getTimeout() |
| def _set_timeout(self, t): |
| if t is not None: |
| t = UnsignedInteger(t) |
| return self.impl.setTimeout(t) |
| timeout = property(_get_timeout, _set_timeout) |
| |
| def copy(self, src): |
| self.address = src.address |
| |
| class Sender(Link): |
| |
| def offered(self, n): |
| raise Skipped() |
| |
| def send(self, bytes): |
| return self.impl.send(bytes, 0, len(bytes)) |
| |
| def drained(self): |
| self.impl.drained() |
| |
| class Receiver(Link): |
| |
| def flow(self, n): |
| self.impl.flow(n) |
| |
| def drain(self, n): |
| self.impl.drain(n) |
| |
| def recv(self, size): |
| output = zeros(size, "b") |
| n = self.impl.recv(output, 0, size) |
| if n >= 0: |
| return output.tostring()[:n] |
| elif n == TransportImpl.END_OF_STREAM: |
| return None |
| else: |
| raise Exception(n) |
| |
| def wrap_delivery(impl): |
| if impl: return Delivery(impl) |
| |
| class Delivery(object): |
| |
| RECEIVED = 1 |
| ACCEPTED = 2 |
| REJECTED = 3 |
| RELEASED = 4 |
| MODIFIED = 5 |
| |
| def __init__(self, impl): |
| self.impl = impl |
| |
| @property |
| def tag(self): |
| return self.impl.getTag().tostring() |
| |
| @property |
| def writable(self): |
| return self.impl.isWritable() |
| |
| @property |
| def readable(self): |
| return self.impl.isReadable() |
| |
| @property |
| def updated(self): |
| return self.impl.isUpdated() |
| |
| def update(self, disp): |
| if disp == self.ACCEPTED: |
| self.impl.disposition(Accepted.getInstance()) |
| else: |
| raise Exception("xxx: %s" % disp) |
| |
| @property |
| def remote_state(self): |
| rd = self.impl.getRemoteState() |
| if(rd == Accepted.getInstance()): |
| return self.ACCEPTED |
| else: |
| raise Exception("xxx: %s" % rd) |
| |
| @property |
| def local_state(self): |
| ld = self.impl.getLocalState() |
| if(ld == Accepted.getInstance()): |
| return self.ACCEPTED |
| else: |
| raise Exception("xxx: %s" % ld) |
| |
| def settle(self): |
| self.impl.settle() |
| |
| @property |
| def settled(self): |
| return self.impl.remotelySettled() |
| |
| @property |
| def work_next(self): |
| return wrap_delivery(self.impl.getWorkNext()) |
| |
| class Transport(object): |
| |
| TRACE_OFF = 0 |
| TRACE_RAW = 1 |
| TRACE_FRM = 2 |
| TRACE_DRV = 4 |
| |
| def __init__(self): |
| self.impl = TransportImpl() |
| |
| def trace(self, mask): |
| # XXX: self.impl.trace(mask) |
| pass |
| |
| def bind(self, connection): |
| self.impl.bind(connection.impl) |
| |
| def output(self, size): |
| """ has the transport produce up to size bytes returning what was |
| produced to the caller""" |
| output = zeros(size, "b") |
| n = self.impl.output(output, 0, size) |
| if n >= 0: |
| return output.tostring()[:n] |
| elif n == TransportImpl.END_OF_STREAM: |
| return None |
| else: |
| raise Exception("XXX: %s" % n) |
| |
| def input(self, bytes): |
| return self.impl.input(bytes, 0, len(bytes)) |
| |
| def _get_max_frame_size(self): |
| #return pn_transport_get_max_frame(self._trans) |
| raise Skipped() |
| |
| def _set_max_frame_size(self, value): |
| #pn_transport_set_max_frame(self._trans, value) |
| raise Skipped() |
| |
| max_frame_size = property(_get_max_frame_size, _set_max_frame_size, |
| doc=""" |
| Sets the maximum size for received frames (in bytes). |
| """) |
| |
| @property |
| def remote_max_frame_size(self): |
| #return pn_transport_get_remote_max_frame(self._trans) |
| raise Skipped() |
| |
| # AMQP 1.0 idle-time-out |
| def _get_idle_timeout(self): |
| #return pn_transport_get_idle_timeout(self._trans) |
| raise Skipped() |
| |
| def _set_idle_timeout(self, value): |
| #pn_transport_set_idle_timeout(self._trans, value) |
| raise Skipped() |
| |
| idle_timeout = property(_get_idle_timeout, _set_idle_timeout, |
| doc=""" |
| The idle timeout of the connection (in milliseconds). |
| """) |
| |
| @property |
| def remote_idle_timeout(self): |
| #return pn_transport_get_remote_idle_timeout(self._trans) |
| raise Skipped() |
| |
| @property |
| def frames_output(self): |
| #return pn_transport_get_frames_output(self._trans) |
| raise Skipped() |
| |
| @property |
| def frames_input(self): |
| #return pn_transport_get_frames_input(self._trans) |
| raise Skipped() |
| |
| class symbol(unicode): |
| |
| def __repr__(self): |
| return "symbol(%s)" % unicode.__repr__(self) |
| |
| class Data(object): |
| |
| SYMBOL = None |
| |
| def __init__(self, *args, **kwargs): |
| raise Skipped() |
| |
| class Messenger(object): |
| |
| def __init__(self, *args, **kwargs): |
| self.impl = MessengerImpl() |
| |
| def start(self): |
| self.impl.start() |
| |
| def stop(self): |
| self.impl.stop() |
| |
| def subscribe(self, source): |
| self.impl.subscribe(source) |
| |
| def put(self, message): |
| self.impl.put(message.impl) |
| return self.impl.outgoingTracker() |
| |
| def send(self): |
| self.impl.send() |
| |
| def recv(self, n): |
| self.impl.recv(n) |
| |
| def get(self, message=None): |
| result = self.impl.get() |
| if message and result: |
| message.impl = result |
| return self.impl.incomingTracker() |
| |
| @property |
| def outgoing(self): |
| return self.impl.outgoing() |
| |
| @property |
| def incoming(self): |
| return self.impl.incoming() |
| |
| def _get_timeout(self): |
| return self.impl.getTimeout() |
| def _set_timeout(self, t): |
| self.impl.setTimeout(t) |
| timeout = property(_get_timeout, _set_timeout) |
| |
| def accept(self, tracker=None): |
| if tracker is None: |
| tracker = self.impl.incomingTracker() |
| flags = self.impl.CUMULATIVE |
| else: |
| flags = 0 |
| self.impl.accept(tracker, flags) |
| |
| def reject(self, tracker=None): |
| if tracker is None: |
| tracker = self.impl.incomingTracker() |
| flags = self.impl.CUMULATIVE |
| else: |
| flags = 0 |
| self.impl.reject(tracker, flags) |
| |
| def settle(self, tracker=None): |
| if tracker is None: |
| tracker = self.impl.outgoingTracker() |
| flags = self.impl.CUMULATIVE |
| else: |
| flags = 0 |
| self.impl.settle(tracker, flags) |
| |
| def status(self, tracker): |
| return STATUSES[self.impl.getStatus(tracker)] |
| |
| def _get_incoming_window(self): |
| return self.impl.getIncomingWindow() |
| def _set_incoming_window(self, window): |
| self.impl.setIncomingWindow(window) |
| incoming_window = property(_get_incoming_window, _set_incoming_window) |
| |
| def _get_outgoing_window(self): |
| return self.impl.getOutgoingWindow() |
| def _set_outgoing_window(self, window): |
| self.impl.setOutgoingWindow(window) |
| outgoing_window = property(_get_outgoing_window, _set_outgoing_window) |
| |
| |
| class Message(object): |
| |
| AMQP = MessageFormat.AMQP |
| TEXT = MessageFormat.TEXT |
| DATA = MessageFormat.DATA |
| JSON = MessageFormat.JSON |
| |
| DEFAULT_PRIORITY = MessageImpl.DEFAULT_PRIORITY |
| |
| def __init__(self): |
| self.impl = MessageImpl() |
| |
| def clear(self): |
| self.impl.clear() |
| |
| def save(self): |
| saved = self.impl.save() |
| if saved is None: |
| saved = "" |
| elif not isinstance(saved, unicode): |
| saved = saved.tostring() |
| return saved |
| |
| def load(self, data): |
| self.impl.load(data) |
| |
| def encode(self): |
| size = 1024 |
| output = zeros(size, "b") |
| while True: |
| n = self.impl.encode(output, 0, size) |
| # XXX: need to check for overflow |
| if n > 0: |
| return output.tostring()[:n] |
| else: |
| raise Exception(n) |
| |
| def decode(self, data): |
| self.impl.decode(data,0,len(data)) |
| |
| def _get_id(self): |
| id = self.impl.getMessageId() |
| if isinstance(id, JUUID): |
| id = UUID( id.toString() ) |
| return id |
| def _set_id(self, value): |
| if isinstance(value, UUID): |
| value = JUUID.fromString( str(value) ) |
| return self.impl.setMessageId(value) |
| id = property(_get_id, _set_id) |
| |
| def _get_correlation_id(self): |
| id = self.impl.getCorrelationId() |
| if isinstance(id, JUUID): |
| id = UUID( id.toString() ) |
| return id |
| def _set_correlation_id(self, value): |
| if isinstance(value, UUID): |
| value = JUUID.fromString( str(value) ) |
| return self.impl.setCorrelationId(value) |
| correlation_id = property(_get_correlation_id, _set_correlation_id) |
| |
| def _get_ttl(self): |
| return self.impl.getTtl() |
| def _set_ttl(self, ttl): |
| self.impl.setTtl(ttl) |
| ttl = property(_get_ttl, _set_ttl) |
| |
| def _get_priority(self): |
| return self.impl.getPriority() |
| def _set_priority(self, priority): |
| self.impl.setPriority(priority) |
| priority = property(_get_priority, _set_priority) |
| |
| def _get_address(self): |
| return self.impl.getAddress() |
| def _set_address(self, address): |
| self.impl.setAddress(address) |
| address = property(_get_address, _set_address) |
| |
| def _get_subject(self): |
| return self.impl.getSubject() |
| def _set_subject(self, subject): |
| self.impl.setSubject(subject) |
| subject = property(_get_subject, _set_subject) |
| |
| def _get_user_id(self): |
| u = self.impl.getUserId() |
| if u is None: return "" |
| else: return u.tostring() |
| def _set_user_id(self, user_id): |
| self.impl.setUserId(user_id) |
| user_id = property(_get_user_id, _set_user_id) |
| |
| def _get_reply_to(self): |
| return self.impl.getReplyTo() |
| def _set_reply_to(self, reply_to): |
| self.impl.setReplyTo(reply_to) |
| reply_to = property(_get_reply_to, _set_reply_to) |
| |
| def _get_reply_to_group_id(self): |
| return self.impl.getReplyToGroupId() |
| def _set_reply_to_group_id(self, reply_to_group_id): |
| self.impl.setReplyToGroupId(reply_to_group_id) |
| reply_to_group_id = property(_get_reply_to_group_id, _set_reply_to_group_id) |
| |
| def _get_group_id(self): |
| return self.impl.getGroupId() |
| def _set_group_id(self, group_id): |
| self.impl.setGroupId(group_id) |
| group_id = property(_get_group_id, _set_group_id) |
| |
| def _get_group_sequence(self): |
| return self.impl.getGroupSequence() |
| def _set_group_sequence(self, group_sequence): |
| self.impl.setGroupSequence(group_sequence) |
| group_sequence = property(_get_group_sequence, _set_group_sequence) |
| |
| def _is_first_acquirer(self): |
| return self.impl.isFirstAcquirer() |
| def _set_first_acquirer(self, b): |
| self.impl.setFirstAcquirer(b) |
| first_acquirer = property(_is_first_acquirer, _set_first_acquirer) |
| |
| def _get_expiry_time(self): |
| return self.impl.getExpiryTime() |
| def _set_expiry_time(self, expiry_time): |
| self.impl.setExpiryTime(expiry_time) |
| expiry_time = property(_get_expiry_time, _set_expiry_time) |
| |
| def _is_durable(self): |
| return self.impl.isDurable() |
| def _set_durable(self, durable): |
| self.impl.setDurable(durable) |
| durable = property(_is_durable, _set_durable) |
| |
| def _get_delivery_count(self): |
| return self.impl.getDeliveryCount() |
| def _set_delivery_count(self, delivery_count): |
| self.impl.setDeliveryCount(delivery_count) |
| delivery_count = property(_get_delivery_count, _set_delivery_count) |
| |
| def _get_creation_time(self): |
| return self.impl.getCreationTime() |
| def _set_creation_time(self, creation_time): |
| self.impl.setCreationTime(creation_time) |
| creation_time = property(_get_creation_time, _set_creation_time) |
| |
| def _get_content_type(self): |
| return self.impl.getContentType() |
| def _set_content_type(self, content_type): |
| self.impl.setContentType(content_type) |
| content_type = property(_get_content_type, _set_content_type) |
| |
| def _get_content_encoding(self): |
| return self.impl.getContentEncoding() |
| def _set_content_encoding(self, content_encoding): |
| self.impl.setContentEncoding(content_encoding) |
| content_encoding = property(_get_content_encoding, _set_content_encoding) |
| |
| def _get_format(self): |
| return self.impl.getFormat() |
| def _set_format(self, format): |
| self.impl.setMessageFormat(format) |
| format = property(_get_format, _set_format) |
| |
| def _get_body(self): |
| body = self.impl.getBody() |
| if isinstance(body, AmqpValue): |
| return body.getValue() |
| else: |
| return body |
| def _set_body(self, body): |
| self.impl.setBody(AmqpValue(body)) |
| body = property(_get_body, _set_body) |
| |
| |
| class SASL(object): |
| |
| OK = Sasl.PN_SASL_OK |
| AUTH = Sasl.PN_SASL_AUTH |
| |
| def __init__(self,transport): |
| self._sasl = transport.impl.sasl() |
| |
| def mechanisms(self, mechanisms): |
| self._sasl.setMechanisms(mechanisms.split()) |
| |
| def client(self): |
| self._sasl.client() |
| |
| def server(self): |
| self._sasl.server() |
| |
| def send(self, data): |
| self._sasl.send(data, 0, len(data)) |
| |
| def recv(self): |
| size = 4096 |
| output = zeros(size, "b") |
| n = self._sasl.recv(output, 0, size) |
| if n >= 0: |
| return output.tostring()[:n] |
| elif n == TransportImpl.END_OF_STREAM: |
| return None |
| else: |
| raise Exception(n) |
| |
| def _get_outcome(self): |
| value = self._sasl.getOutcome() |
| if value == Sasl.PN_SASL_NONE: |
| return None |
| else: |
| return value |
| def _set_outcome(self, outcome): |
| self.impl.setOutcome(outcome) |
| |
| outcome = property(_get_outcome, _set_outcome) |
| |
| def done(self, outcome): |
| self._sasl.done(outcome) |
| |
| def plain(self, user, password): |
| self._sasl.plain(user,password) |
| |
| class SSLException(Exception): |
| pass |
| |
| class SSLUnavailable(SSLException): |
| pass |
| |
| class SSLDomain(object): |
| |
| MODE_SERVER = SslDomain.Mode.SERVER |
| MODE_CLIENT = SslDomain.Mode.CLIENT |
| VERIFY_PEER = SslDomain.VerifyMode.VERIFY_PEER |
| ANONYMOUS_PEER = SslDomain.VerifyMode.ANONYMOUS_PEER |
| VERIFY_PEER_NAME = None # TBD |
| |
| def __init__(self, mode): |
| self._domain = SslDomainImpl() |
| self._domain.init(mode) |
| |
| def set_credentials(self, cert_file, key_file, password): |
| self._domain.setCredentials(cert_file, key_file, password) |
| |
| def set_trusted_ca_db(self, certificate_db): |
| self._domain.setTrustedCaDb(certificate_db) |
| |
| def set_peer_authentication(self, verify_mode, trusted_CAs=None): |
| self._domain.setPeerAuthentication(verify_mode) |
| if trusted_CAs is not None: |
| self._domain.setTrustedCaDb(trusted_CAs) |
| |
| def allow_unsecured_client(self, allow_unsecured = True): |
| self._domain.allowUnsecuredClient(allow_unsecured) |
| |
| class SSLSessionDetails(object): |
| |
| def __init__(self, session_id): |
| self._session_details = SslPeerDetailsImpl(session_id, 1) |
| |
| class SSL(object): |
| |
| def __init__(self, transport, domain, session_details=None): |
| |
| internal_session_details = None |
| if session_details: |
| internal_session_details = session_details._session_details |
| |
| self._ssl = transport.impl.ssl(domain._domain, internal_session_details) |
| self._session_details = session_details |
| |
| def get_session_details(self): |
| return self._session_details |
| |
| def cipher_name(self): |
| return self._ssl.getCipherName() |
| |
| def protocol_name(self): |
| return self._ssl.getProtocolName() |
| |
| def _set_peer_hostname(self, hostname): |
| raise Skipped() |
| def _get_peer_hostname(self): |
| raise Skipped() |
| peer_hostname = property(_get_peer_hostname, _set_peer_hostname) |
| |
| |
| class Driver(object): |
| """ Proton-c platform abstraction - not needed.""" |
| def __init__(self, *args, **kwargs): |
| raise Skipped() |
| class Connector(object): |
| """ Proton-c platform abstraction - not needed.""" |
| def __init__(self, *args, **kwargs): |
| raise Skipped() |
| class Listener(object): |
| """ Proton-c platform abstraction - not needed.""" |
| def __init__(self, *args, **kwargs): |
| raise Skipped() |
| |
| __all__ = [ |
| "ACCEPTED", |
| "LANGUAGE", |
| "MANUAL", |
| "PENDING", |
| "REJECTED", |
| "PN_SESSION_WINDOW", |
| "Condition", |
| "Connection", |
| "Connector", |
| "Data", |
| "Delivery", |
| "Driver", |
| "Endpoint", |
| "Link", |
| "Listener", |
| "Message", |
| "MessageException", |
| "Messenger", |
| "MessengerException", |
| "ProtonException", |
| "Receiver", |
| "SASL", |
| "Sender", |
| "Session", |
| "SSL", |
| "SSLDomain", |
| "SSLException", |
| "SSLSessionDetails", |
| "SSLUnavailable", |
| "symbol", |
| "Terminus", |
| "Timeout", |
| "Transport", |
| "TransportException"] |