from django.views.decorators.csrf import csrf_exempt
from django.views.generic import View
from functools import wraps
import settings
from os import path
from tastypie.http import HttpForbidden
from chroma_core.models import ManagedHost, ClientCertificate, RegistrationToken, ServerProfile, Bundle
from chroma_core.models.copytool import Copytool, CopytoolEvent, CopytoolOperation, log as copytool_log, UNKNOWN_UUID
from chroma_core.models.log import LogMessage, MessageClass
from chroma_core.models.utils import Version
from chroma_core.services import log_register
from chroma_core.services.http_agent.crypto import Crypto
from iml_common.lib.date_time import IMLDateTime
log = log_register('agent_views')
import logging
log.setLevel(logging.WARN)
def log_exception(f):
@wraps(f)
def wrapped(*args, **kwargs):
try:
return f(*args)
except Exception:
log.error(traceback.format_exc())
raise
return wrapped
# Copyright (c) 2020 DDN. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
from chroma_core.services import log_register
from chroma_core.models import SyslogEvent, ClientConnectEvent, ManagedHost
from django.db import transaction
import logging
import re
syslog_events_log = log_register("syslog_events")
_re_cache = {}
def _re_find_one_in_many(haystack, needles):
"""Find the first instance of any of 'needles' in haystack"""
if not isinstance(needles, tuple):
needles = tuple(needles)
try:
expr = _re_cache[needles]
except:
expr = re.compile("|".join([re.escape(n) for n in needles]))
_re_cache[needles] = expr
result = expr.search(haystack)
if result:
return result.group(0)
else:
return None
# Copyright (c) 2018 DDN. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
from chroma_core.services import log_register
from chroma_core.models import SyslogEvent, ClientConnectEvent, ManagedHost
from django.db import transaction
import logging
import re
syslog_events_log = log_register('syslog_events')
_re_cache = {}
def _re_find_one_in_many(haystack, needles):
"""Find the first instance of any of 'needles' in haystack"""
if not isinstance(needles, tuple):
needles = tuple(needles)
try:
expr = _re_cache[needles]
except:
expr = re.compile("|".join([re.escape(n) for n in needles]))
_re_cache[needles] = expr
result = expr.search(haystack)
if result:
return result.group(0)
else:
return None
from django.views.generic import View
from functools import wraps
import settings
from os import path
from tastypie.http import HttpForbidden
from chroma_core.models.host import ManagedHost
from chroma_core.models import ClientCertificate, RegistrationToken, ServerProfile
from chroma_core.models.copytool import Copytool, CopytoolEvent, CopytoolOperation, log as copytool_log, UNKNOWN_UUID
from chroma_core.models.log import LogMessage, MessageClass
from chroma_core.models.utils import Version
from chroma_core.services import log_register
from chroma_core.services.crypto import Crypto
from iml_common.lib.date_time import IMLDateTime
log = log_register("agent_views")
import logging
log.setLevel(logging.WARN)
def log_exception(f):
@wraps(f)
def wrapped(*args, **kwargs):
try:
return f(*args)
except Exception:
log.error(traceback.format_exc())
raise
return wrapped
# Copyright (c) 2017 Intel Corporation. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
import django.db.models
from chroma_core.services import log_register
from chroma_core.chroma_common.lib.agent_rpc import agent_result
job_log = log_register('job')
class Dependable(object):
def all(self):
if hasattr(self, 'objects'):
for o in self.objects:
for i in o.all():
yield i
else:
yield self
def debug_list(self):
if hasattr(self, 'objects'):
result = []
for o in self.objects:
result.append((o.__class__.__name__, o.debug_list()))
return result
else:
return [self.stateful_object, self.acceptable_states]
def satisfied(self):
# Copyright (c) 2017 Intel Corporation. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
import threading
from django.db.models.signals import post_save
from django.contrib.auth.models import User
from django.core.mail import send_mail
from django.db.models import Count
from chroma_core.services import log_register
from chroma_core.models.alert import AlertState, AlertEmail
logging = log_register('email_alerts')
class MailAlerts(threading.Thread):
def __init__(self, sender, subject_prefix, host):
super(MailAlerts, self).__init__()
self.sender = sender
self.subject_prefix = subject_prefix
self.host = host
self.change_event = threading.Event()
self.exit = False
post_save.connect(self._table_changed)
def run(self):
while self.exit is False:
# Copyright (c) 2020 DDN. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
from chroma_core.services import log_register
from chroma_api.related_field import RelatedField
assert RelatedField # silence pyflakes
api_log = log_register("django.request.tastypie")
from chroma_core.lib.storage_plugin.api import resources
from chroma_core.lib.storage_plugin.api.plugin import Plugin
from chroma_core.models import HaCluster
from chroma_core.plugins.block_devices import get_devices
from chroma_core.services import log_register
from chroma_core.services.job_scheduler.job_scheduler_client import JobSchedulerClient
# This plugin is special, it uses chroma-manager internals
# in a way that third party plugins can't/shouldn't/mustn't
from chroma_core.lib.storage_plugin.base_resource import HostsideResource
from chroma_core.models import ManagedHost
from chroma_core.models import VolumeNode
from settings import SERIAL_PREFERENCE
log = log_register('plugin_runner')
log.setLevel(DEBUG)
version = 1
class PluginAgentResources(resources.Resource, HostsideResource):
class Meta:
identifier = GlobalId('host_id', 'plugin_name')
host_id = attributes.Integer()
plugin_name = attributes.String()
def get_label(self):
host = ManagedHost._base_manager.get(pk=self.host_id)
return "%s" % host
# Copyright (c) 2020 DDN. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
import threading
from django.db.models.signals import post_save
from django.contrib.auth.models import User
from django.core.mail import send_mail
from django.db.models import Count
from chroma_core.services import log_register
from chroma_core.models.alert import AlertState, AlertEmail
logging = log_register("email_alerts")
class MailAlerts(threading.Thread):
def __init__(self, sender, subject_prefix, host):
super(MailAlerts, self).__init__()
self.sender = sender
self.subject_prefix = subject_prefix
self.host = host
self.change_event = threading.Event()
self.exit = False
post_save.connect(self._table_changed)
def run(self):
while self.exit is False:
# Copyright (c) 2018 DDN. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
"""This module defines a simple logger which is used by storage_plugin.* and
provided for use by BaseStoragePlugin subclasses"""
from chroma_core.services import log_register
storage_plugin_log = log_register("storage_plugin")
# Copyright (c) 2017 Intel Corporation. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
from django.db import models
from django.db.models import CharField, ForeignKey, IntegerField
from chroma_core.services import log_register
from iml_common.lib.package_version_info import VersionInfo
log = log_register('package_update')
class Package(models.Model):
class Meta:
app_label = 'chroma_core'
name = CharField(max_length=128, unique=True)
class PackageVersion(models.Model):
class Meta:
app_label = 'chroma_core'
unique_together = ('package', 'version', 'release')
package = ForeignKey('Package')
epoch = IntegerField()
version = CharField(max_length=128)
release = CharField(max_length=128)
arch = CharField(max_length=32)
class Crypto(CommandLine):
# The manager's local key and certificate, used for
# identifying itself to agents and to API clients such
# as web browsers and the command line interface.
MANAGER_KEY_FILE = os.path.join(settings.CRYPTO_FOLDER, 'manager.pem')
MANAGER_CERT_FILE = os.path.join(settings.CRYPTO_FOLDER, 'manager.crt')
# The local CA used for issuing certificates to agents, and
# for signing the manager cert if an externally signed cert
# is not provided
AUTHORITY_KEY_FILE = os.path.join(settings.CRYPTO_FOLDER, 'authority.pem')
AUTHORITY_CERT_FILE = os.path.join(settings.CRYPTO_FOLDER, 'authority.crt')
# Certificate duration: we don't use expiration/reissue, so
# this is set to a 'forever' value.
CERTIFICATE_DAYS = "36500"
log = log_register('crypto')
def _get_or_create_private_key(self, filename):
if not os.path.exists(filename):
self.log.info("Generating manager key file")
self.try_shell(['openssl', 'genrsa', '-out', filename, '2048'])
return filename
@property
def authority_key(self):
"""
Get the path to the authority key, or generate one
"""
return self._get_or_create_private_key(self.AUTHORITY_KEY_FILE)
@property
def authority_cert(self):
"""
Get the path to the authority certificate, or self-sign the authority key to generate one
"""
if not os.path.exists(self.AUTHORITY_CERT_FILE):
rc, csr, err = self.try_shell([
"openssl", "req", "-new", "-sha256", "-subj",
"/C=/ST=/L=/O=/CN=x_local_authority", "-key",
self.authority_key
])
rc, out, err = self.try_shell([
"openssl", "x509", "-req", "-sha256", "-days",
self.CERTIFICATE_DAYS, "-signkey", self.authority_key, "-out",
self.AUTHORITY_CERT_FILE
],
stdin_text=csr)
return self.AUTHORITY_CERT_FILE
@property
def server_key(self):
return self._get_or_create_private_key(self.MANAGER_KEY_FILE)
@property
def server_cert(self):
if not os.path.exists(self.MANAGER_CERT_FILE):
# Determine what domain name HTTP clients will
# be using to access me, and bake that into my
# certificate (using SERVER_HTTP_URL re
hostname = urlparse.urlparse(settings.SERVER_HTTP_URL).hostname
self.log.info("Generating manager certificate file")
rc, csr, err = self.try_shell([
"openssl", "req", "-new", "-sha256", "-subj",
"/C=/ST=/L=/O=/CN=%s" % hostname, "-key", self.server_key
])
rc, out, err = self.try_shell([
"openssl", "x509", "-req", "-sha256", "-days",
self.CERTIFICATE_DAYS, "-CA", self.authority_cert,
"-CAcreateserial", "-CAkey", self.authority_key, "-out",
self.MANAGER_CERT_FILE
],
stdin_text=csr)
self.log.info("Generated %s" % self.MANAGER_CERT_FILE)
return self.MANAGER_CERT_FILE
def get_common_name(self, csr_string):
rc, out, err = self.try_shell(['openssl', 'req', '-noout', '-subject'],
stdin_text=csr_string)
return re.search("/CN=([^/]+)", out).group(1).strip()
def sign(self, csr_string):
self.log.info("Signing")
rc, out, err = self.try_shell([
"openssl", "x509", "-req", "-days", self.CERTIFICATE_DAYS,
"-CAkey", self.authority_key, "-CA", self.authority_cert,
"-CAcreateserial", "-sha256"
],
stdin_text=csr_string)
return out.strip()
def get_serial(self, cert_str):
rc, out, err = self.try_shell(
['openssl', 'x509', '-serial', '-noout', '-sha256'],
stdin_text=cert_str)
# Output like "serial=foo"
return out.strip().split("=")[1]
# Copyright (c) 2017 Intel Corporation. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
import logging
import threading
import datetime
from chroma_agent_comms.views import MessageView
from chroma_core.models import ManagedHost, HostContactAlert, HostRebootEvent
from chroma_core.services import log_register
from chroma_core.services.job_scheduler import job_scheduler_notify
from iml_common.lib.date_time import IMLDateTime
log = log_register("http_agent_host_state")
class HostState(object):
"""
The http_agent service maintains some per-host state unrelated to
managing communication sessions, in order to detect and report
reboots and generate timeouts.
"""
# We get an update at the start of every long poll
CONTACT_TIMEOUT = MessageView.LONG_POLL_TIMEOUT * 2
def __init__(self, fqdn, boot_time, client_start_time):
self.last_contact = None
self.fqdn = fqdn
self._healthy = False
import os
import dse
from django.db import transaction
from chroma_core.services.syslog.parser import LogMessageParser
from chroma_core.models.log import LogMessage
from chroma_core.services import ChromaService, log_register
from chroma_core.services.queue import AgentRxQueue
from iml_common.lib.date_time import IMLDateTime
import settings
log = log_register('systemd_journal')
class Service(ChromaService):
PLUGIN_NAME = 'systemd_journal'
def __init__(self):
super(Service, self).__init__()
self._queue = AgentRxQueue(Service.PLUGIN_NAME)
self._queue.purge()
self._table_size = LogMessage.objects.count()
self._parser = LogMessageParser()
dse.patch_models()
def _check_size(self):
from chroma_core.lib.job import DependOn
from chroma_core.lib.job import DependAll
from chroma_core.lib.job import Step
from chroma_core.lib.cache import ObjectCache
from chroma_core.models.client_mount import LustreClientMount
from chroma_core.models.jobs import StateChangeJob
from chroma_core.models.jobs import StatefulObject
from chroma_core.models.jobs import Job
from chroma_core.models.jobs import AdvertisedJob
from chroma_core.models.utils import DeletableDowncastableMetaclass
from chroma_core.models.utils import CHARFIELD_MAX_LENGTH
from chroma_core.models.utils import MeasuredEntity
from chroma_help.help import help_text
from iml_common.lib.date_time import IMLDateTime
log = log_register(__name__.split(".")[-1])
# special uuid used to flag a copytool that wasn't properly registered
UNKNOWN_UUID = "00000000-0000-0000-0000-000000000000"
# poor-man's enum
OP_STATES = namedtuple("STATES", "UNKNOWN, STARTED, RUNNING, FINISHED, ERRORED")(0, 1, 2, 3, 4)
OP_TYPES = namedtuple("TYPES", "UNKNOWN, ARCHIVE, RESTORE, REMOVE")(0, 1, 2, 3)
def resolve_value(container, key):
if container == "state":
return OP_STATES._asdict()[key]
elif container == "type":
return OP_TYPES._asdict()[key]
else:
from chroma_core.lib.job import DependOn
from chroma_core.lib.job import DependAll
from chroma_core.lib.job import Step
from chroma_core.lib.cache import ObjectCache
from chroma_core.models.client_mount import LustreClientMount
from chroma_core.models.jobs import StateChangeJob
from chroma_core.models.jobs import StatefulObject
from chroma_core.models.jobs import Job
from chroma_core.models.jobs import AdvertisedJob
from chroma_core.models.utils import DeletableDowncastableMetaclass
from chroma_core.models.utils import CHARFIELD_MAX_LENGTH
from chroma_core.models.utils import MeasuredEntity
from chroma_help.help import help_text
from iml_common.lib.date_time import IMLDateTime
log = log_register(__name__.split('.')[-1])
# special uuid used to flag a copytool that wasn't properly registered
UNKNOWN_UUID = '00000000-0000-0000-0000-000000000000'
# poor-man's enum
OP_STATES = namedtuple('STATES',
'UNKNOWN, STARTED, RUNNING, FINISHED, ERRORED')(0, 1, 2,
3, 4)
OP_TYPES = namedtuple('TYPES', 'UNKNOWN, ARCHIVE, RESTORE, REMOVE')(0, 1, 2, 3)
def resolve_value(container, key):
if container == 'state':
return OP_STATES._asdict()[key]
elif container == 'type':
# Copyright (c) 2017 Intel Corporation. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
from chroma_core.services import log_register
from chroma_api.related_field import RelatedField
assert RelatedField # silence pyflakes
api_log = log_register('django.request.tastypie')
class Crypto(CommandLine):
# The manager's local key and certificate, used for
# identifying itself to agents and to API clients such
# as web browsers and the command line interface.
MANAGER_KEY_FILE = os.path.join(settings.CRYPTO_FOLDER, "manager.pem")
MANAGER_CERT_FILE = os.path.join(settings.CRYPTO_FOLDER, "manager.crt")
# The local CA used for issuing certificates to agents, and
# for signing the manager cert if an externally signed cert
# is not provided
AUTHORITY_KEY_FILE = os.path.join(settings.CRYPTO_FOLDER, "authority.pem")
AUTHORITY_CERT_FILE = os.path.join(settings.CRYPTO_FOLDER, "authority.crt")
# Certificate duration: we don't use expiration/reissue, so
# this is set to a 'forever' value.
CERTIFICATE_DAYS = "36500"
log = log_register("crypto")
def _get_or_create_private_key(self, filename):
if not os.path.exists(filename):
self.log.info("Generating manager key file")
self.try_shell(
["openssl", "genrsa", "-out", filename, "2048", "-sha256"])
return filename
@property
def authority_key(self):
"""
Get the path to the authority key, or generate one
"""
return self._get_or_create_private_key(self.AUTHORITY_KEY_FILE)
@property
def authority_cert(self):
"""
Get the path to the authority certificate, or self-sign the authority key to generate one
"""
if not os.path.exists(self.AUTHORITY_CERT_FILE):
rc, csr, err = self.try_shell([
"openssl",
"req",
"-new",
"-sha256",
"-subj",
"/C=AA/ST=AA/L=Location/O=Org/CN=x_local_authority",
"-key",
self.authority_key,
])
rc, out, err = self.try_shell(
[
"openssl",
"x509",
"-req",
"-sha256",
"-days",
self.CERTIFICATE_DAYS,
"-signkey",
self.authority_key,
"-out",
self.AUTHORITY_CERT_FILE,
],
stdin_text=csr,
)
return self.AUTHORITY_CERT_FILE
@property
def server_key(self):
return self._get_or_create_private_key(self.MANAGER_KEY_FILE)
@property
def server_cert(self):
if not os.path.exists(self.MANAGER_CERT_FILE):
# Determine what domain name HTTP clients will
# be using to access me, and bake that into my
# certificate (using SERVER_HTTP_URL re
hostname = urlparse.urlparse(settings.SERVER_HTTP_URL).hostname
fd, tmp_path = tempfile.mkstemp()
f = os.fdopen(fd, "w")
f.write("""
[ req ]
distinguished_name = req_distinguished_name
req_extensions = v3_req
x509_extensions = v3_req
prompt = no
[ req_distinguished_name ]
CN = %s
[ v3_req ]
# Extensions to add to a certificate request
subjectKeyIdentifier = hash
basicConstraints = critical,CA:false
keyUsage = critical,digitalSignature,keyEncipherment
subjectAltName = DNS:%s
""" % (hostname, hostname))
f.close()
self.log.info("Generating manager certificate file")
_, csr, _ = self.try_shell([
"openssl", "req", "-new", "-sha256", "-key", self.server_key,
"-config", tmp_path
])
self.try_shell(
[
"openssl",
"x509",
"-req",
"-sha256",
"-days",
self.CERTIFICATE_DAYS,
"-extfile",
tmp_path,
"-extensions",
"v3_req",
"-CA",
self.authority_cert,
"-CAcreateserial",
"-CAkey",
self.authority_key,
"-out",
self.MANAGER_CERT_FILE,
],
stdin_text=csr,
)
self.log.info("Generated %s" % self.MANAGER_CERT_FILE)
return self.MANAGER_CERT_FILE
def get_common_name(self, csr_string):
rc, out, err = self.try_shell(["openssl", "req", "-noout", "-subject"],
stdin_text=csr_string)
return re.search("/?CN\s?=\s?([^/]+)", out).group(1).strip()
def sign(self, csr_string):
self.log.info("Signing")
rc, out, err = self.try_shell(
[
"openssl",
"x509",
"-req",
"-days",
self.CERTIFICATE_DAYS,
"-CAkey",
self.authority_key,
"-CA",
self.authority_cert,
"-CAcreateserial",
"-sha256",
],
stdin_text=csr_string,
)
return out.strip()
def get_serial(self, cert_str):
rc, out, err = self.try_shell(
["openssl", "x509", "-serial", "-noout", "-sha256"],
stdin_text=cert_str)
# Output like "serial=foo"
return out.strip().split("=")[1]
# Copyright (c) 2018 DDN. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
import time
import heapq
import collections
from datetime import datetime
from chroma_core.services import log_register
from django.utils.timezone import utc
from chroma_core.models import Point, Series, Stats, ManagedHost, ManagedTarget, ManagedFilesystem
from chroma_core.lib.storage_plugin.api import statistics
from chroma_core.lib import scheduler
metrics_log = log_register('metrics')
class Counter(dict):
"collections.Counter (builtin in 2.7)"
def __missing__(self, key):
return 0
def update(self, other):
for key in other:
self[key] += other[key]
class MetricStore(object):
"""
Base class for metric stores.
# license that can be found in the LICENSE file.
import os
import dse
from django.db import transaction
from chroma_core.services.syslog.parser import LogMessageParser
from chroma_core.models.log import LogMessage
from chroma_core.services import ChromaService, log_register
from chroma_core.services.queue import AgentRxQueue
from chroma_core.chroma_common.lib.date_time import IMLDateTime
import settings
log = log_register('syslog')
class Service(ChromaService):
PLUGIN_NAME = 'syslog'
def __init__(self):
super(Service, self).__init__()
self._queue = AgentRxQueue(Service.PLUGIN_NAME)
self._queue.purge()
self._table_size = LogMessage.objects.count()
self._parser = LogMessageParser()
dse.patch_models()
def _check_size(self):
"""
Registered job scheduler plugins:
slurm_job_id, job_id, lsb_jobid, loadl_step_id, pbs_jobid, procname_uid.
Modules will be loaded dynamically as needed.
Plugins must implement fetch function as documented.
Plugins should also document the available metadata fields.
"""
import importlib
from chroma_core.services import log_register
FIELDS = ("id",)
log = log_register("metrics")
def fetch(ids):
"""Given an iterable of job ids, return an interable of associated metadata dicts.
Ids will be unique and requested in batch whenever possible.
Plugins are responsible for any caching necessary for performance.
"""
for id in ids:
yield {"id": id}
def metadata(jobid_var, field, job_ids):
"""Dispatch set of job_ids to the appropriate plugin.
Return mapping of job_ids to the requested field.
"""
# Copyright (c) 2020 DDN. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
import json
import django.db.models
from chroma_core.services import log_register
from chroma_core.lib.util import invoke_rust_agent, invoke_rust_local_action, RustAgentCancellation
from iml_common.lib.agent_rpc import agent_result
job_log = log_register("job")
def is_string(obj):
try:
return isinstance(obj, basestring) # python 2
except NameError:
return isinstance(obj, str) # python 3
class Dependable(object):
def all(self):
if hasattr(self, "objects"):
for o in self.objects:
for i in o.all():
yield i
else:
yield self
def debug_list(self):
# Copyright (c) 2017 Intel Corporation. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
"""This module defines a simple logger which is used by storage_plugin.* and
provided for use by BaseStoragePlugin subclasses"""
from chroma_core.services import log_register
storage_plugin_log = log_register('storage_plugin')
from chroma_core.lib.storage_plugin.api import resources
from chroma_core.lib.storage_plugin.api.plugin import Plugin
from chroma_core.models import HaCluster
from chroma_core.plugins.block_devices import get_devices
from chroma_core.services import log_register
from chroma_core.services.job_scheduler.job_scheduler_client import JobSchedulerClient
# This plugin is special, it uses chroma-manager internals
# in a way that third party plugins can't/shouldn't/mustn't
from chroma_core.lib.storage_plugin.base_resource import HostsideResource
from chroma_core.models import ManagedHost
from chroma_core.models import VolumeNode
from settings import SERIAL_PREFERENCE
log = log_register("plugin_runner")
log.setLevel(DEBUG)
version = 1
class PluginAgentResources(resources.Resource, HostsideResource):
class Meta:
identifier = GlobalId("host_id", "plugin_name")
host_id = attributes.Integer()
plugin_name = attributes.String()
def get_label(self):
host = ManagedHost._base_manager.get(pk=self.host_id)
return "%s" % host
import random
import string
from collections import defaultdict
from django.utils.timezone import now
from django.db import models
from django.db.models import CASCADE
from toolz import dicttoolz
from chroma_core.lib.job import Step, DependAll
from chroma_core.models import corosync_common
from chroma_core.models import CorosyncConfiguration
from chroma_core.services import log_register
from chroma_core.services.job_scheduler import job_scheduler_notify
logging = log_register("corosync2")
class Corosync2Configuration(CorosyncConfiguration):
# We want separate versions from the CorosyncConfiguration
route_map = None
transition_map = None
job_class_map = None
def __str__(self):
return "%s Corosync2 configuration" % self.host
class Meta:
app_label = "chroma_core"
ordering = ["id"]
import threading
import random
import string
from collections import defaultdict
from django.utils.timezone import now
from django.db import models
from chroma_core.services import log_register
from chroma_core.models import CorosyncConfiguration
from chroma_core.models import corosync_common
from chroma_core.lib.job import Step
from chroma_core.services.job_scheduler import job_scheduler_notify
logging = log_register('corosync2')
class Corosync2Configuration(CorosyncConfiguration):
# We want separate versions from the CorosyncConfiguration
route_map = None
transition_map = None
job_class_map = None
def __str__(self):
return "%s Corosync2 configuration" % self.host
class Meta:
app_label = 'chroma_core'
ordering = ['id']
# Copyright (c) 2020 DDN. All rights reserved.
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file.
from chroma_core.services import log_register
from chroma_core.services.power_control.rpc import PowerControlRpc
log = log_register(__name__)
class PowerControlClient(object):
@classmethod
def query_device_outlets(cls, device):
return PowerControlRpc().query_device_outlets(device.id)
@classmethod
def toggle_device_outlets(cls, toggle_state, outlets):
outlet_ids = [o.id for o in outlets]
return PowerControlRpc().toggle_device_outlets(toggle_state, outlet_ids)
@classmethod
def create_device(cls, device_data):
from chroma_core.models import PowerControlDevice
device_id = PowerControlRpc().create_device(device_data)
return PowerControlDevice.objects.get(pk=device_id)
@classmethod
def remove_device(cls, sockaddr):
# license that can be found in the LICENSE file.
import os
from massiviu.context import DelayedContextFrom
from django.db import transaction
from chroma_core.services.syslog.parser import LogMessageParser
from chroma_core.models.log import LogMessage
from chroma_core.services import ChromaService, log_register
from chroma_core.services.queue import AgentRxQueue
from iml_common.lib.date_time import IMLDateTime
import settings
log = log_register("systemd_journal")
class Service(ChromaService):
PLUGIN_NAME = "systemd_journal"
def __init__(self):
super(Service, self).__init__()
self._queue = AgentRxQueue(Service.PLUGIN_NAME)
self._queue.purge()
self._table_size = LogMessage.objects.count()
self._parser = LogMessageParser()
def _check_size(self):
"""Apply a size limit to the table of log messages"""
MAX_ROWS_PER_TRANSACTION = 10000
