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