def __init__(self, store_endpoint, datacenter, default_metric_host,
default_metric_ttl, default_metric_state):
"""
:param store_endpoint: Riemann server endpoint
:type store_endpoint: str
:param datacenter: The current datacenter name
:type datacenter: str
:param default_metric_host: The default host value used when no other
host has been provided from the metric resource_metadata.
:type default_metric_host: str
:param default_metric_ttl: The amount of time in seconds that events
sent to Riemann are retained in its index.
:type default_metric_ttl: int
:param default_metric_state: The default state value used when no other
state has been provided from the metric resource_metadata.
:type default_metric_state: str
"""
super(RiemannClient, self).__init__()
self._store_endpoint = store_endpoint
self.store_uri = urlparse(self.store_endpoint)
self.default_metric_host = default_metric_host
self.default_metric_ttl = default_metric_ttl
self.default_metric_state = default_metric_state
self.datacenter = datacenter
self._transport = self._create_transport(self.store_uri.scheme)
self.client = Client(transport=self._transport, )
def query(q, config):
from oshino.config import Config, load
from riemann_client.client import Client
cfg = load(config)
riemann = cfg.riemann
transport_cls = cfg.riemann.transport
transport = transport_cls(riemann.host, riemann.port)
print("Executing query: {0}".format(q))
with Client(transport) as client:
print(client.query(q))
def __init__(self, config=None):
# Initialize Handler
Handler.__init__(self, config)
if riemann_client is None:
logging.error("Failed to load riemann_client module")
return
# Initialize options
self.host = self.config['host']
self.port = int(self.config['port'])
self.transport = self.config['transport']
# Initialize client
if self.transport == 'tcp':
self.transport = TCPTransport(self.host, self.port)
else:
self.transport = UDPTransport(self.host, self.port)
self.client = Client(self.transport)
self._connect()
def main():
args = parsed_args(sys.argv[1:])
logging_level = logging.DEBUG if args.debug else logging.WARNING
logging.basicConfig(level=logging_level)
try:
if args.protocol == 'tcp':
transport = TCPTransport(args.host, args.port, args.timeout)
elif args.protocol == 'tls':
transport = TLSTransport(
args.host, args.port, args.timeout,
keyfile=args.keyfile, certfile=args.certfile, ca_certs=args.ca_certs)
elif args.protocol == 'udp':
transport = UDPTransport(args.host, args.port)
else:
raise RuntimeError('Transport {} is not supported'.format(args.transport))
fp = fping.Fping(args.fping_cmd, args.probe, interval=args.interval)
client = Client(transport)
for summary in fp.ping_summaries(args.target):
try:
send_summary(client, summary)
except SendError as e:
logging.warning('Unable to send {} to {} ({})'.format(
e.summary, args.host, e))
except Exception as e:
if args.debug:
raise
else:
logging.error('Unhandled exception ({})'.format(e))
return 1
return 0
