def __init__(self, *args, **kwargs): self.log = make_logger() self.log.debug("Creating RubinTokenAuthenticator") # Superclass gives us the Rubin Manager super().__init__(*args, **kwargs) self.auth_refresh_age = 900 self.header_name = "X-Portal-Authorization" self.header_is_authorization = True self.username_claim_field = "uid" self.cached_auth_state = {}
def __init__(self, args=None): self.logger = make_logger() self.repo = None if not args: raise ValueError("args must be set!") self.args = args self.debug = False if args.debug: self.debug = True if self.debug: self.logger.setLevel(logging.DEBUG) self.logger.debug("Debug logging enabled.") namespace = self.args.namespace if not namespace: self.logger.warning("Using kubernetes namespace 'default'") namespace = "default" self.namespace = namespace load_k8s_config() self.client = client.CoreV1Api() self.images = [] self.nodes = [] self.pod_specs = {} self.created_pods = [] self.logger.debug("Arguments: %s" % str(args)) self.command = self.args.command self.cachefile = self.args.cachefile if self.args.list: for image in self.args.list: # Make fully-qualified image name colons = image.count(":") if colons == 0: image = image + ":latest" slashes = image.count("/") if slashes == 0: image = "library/" + image if slashes == 1: image = "registry.hub.docker.com/" + image self.images.append(image) # Cheap way to deduplicate lists self.images = list(set(self.images)) # Not portable to non-Unixy systems. if self.args.timeout >= 0: self.logger.debug("Setting timeout to %d s." % self.args.timeout) signal.signal(signal.SIGALRM, self._timeout_handler) signal.alarm(self.args.timeout) self.config = RubinConfig() secname = self.config.pull_secret_name pull_secret = get_pull_secret(secname, self.client, self.logger) self.pull_secret_reflist = [] if pull_secret: ensure_pull_secret(pull_secret, self.namespace, self.client, self.logger) self.pull_secret_reflist = get_pull_secret_reflist(secname)
def __init__(self, *args, **kwargs): if not self.log: self.log = make_logger() super().__init__(*args, **kwargs) self.delete_grace_period = 25 # K8s takes ten or so, usually self.namespace = self.get_user_namespace() try: self.log.debug("Loading K8s config.") config.load_incluster_config() except ConfigException: config.load_kube_config() self.log.debug("Spawner __init__ done. Namespace '{}'.".format( self.namespace))
def __init__(self, *args, **kwargs): self.log = make_logger() super().__init__(*args, **kwargs) self.log.debug("Creating RubinSpawner.") # Our API and our RBAC API are set in the super() __init__() # We want our own Rubin Manager per spawner. user = self.user if not user: self.log.error("No user found!") raise RuntimeError("Could not create spawner!") auth = user.authenticator if not auth: self.log.error("No authenticator found!") raise RuntimeError("Could not create spawner!") self.log.debug("Creating Rubin Manager from authenticated user.") self.rubin_mgr = RubinMiddleManager( parent=self, authenticator=auth, spawner=self, user=user, config=RubinConfig(), ) self.log.debug("Initialized {}".format(__name__)) self.cached_auth_state = {} self.delete_grace_period = 5 # In the Rubin setup, there is a "provisionator" user, uid/gid 769, # that is who we should start as, unless we are running sudoless. # If we are, we set the uid/gid/supplemental gids accordingly. self.uid = 769 self.gid = 769 self.supplemental_gids = [] # The fields need to be defined; we don't use them. self.fs_gid = None self.extra_labels = {} self.extra_annotations = {} self.image_pull_secrets = None self.privileged = False self.working_dir = None self.lifecycle_hooks = {} # This one will be useful someday. self.init_containers = [] self.lab_service_account = None self.extra_container_config = {} self.extra_pod_config = {} self.extra_containers = []
def _setup_logger(self, level=logging.WARNING, override_root=False): # In Python 3.8 we could use force=True to force the root logger # to override existing defaults # # Don't eliot-log this or load_from_environment or # create_derived_settings, because we initialize an LSSTConfig when # we import jupyterhubutils, and we don't necessarily want to # spam everyone about it # Add our formats fstr = "[%(levelname).1s %(asctime)s.%(msecs).03d" fstr += " %(module)s:%(funcName)s:%(lineno)d] %(message)s" dstr = "%Y-%m-%d %H:%M:%S" self.log_format = fstr self.log_datefmt = dstr self.log_level = level to_file(sys.stderr) if override_root: self.eliotify_root_logger(level=level) self.log = make_logger(level=level)
def __init__( self, host="hub.docker.com", path="", owner="", name="", experimentals=0, dailies=3, weeklies=2, releases=1, recommended=True, port=None, cachefile=None, insecure=False, debug=False, ): self.data = {} self.display_tags = [] self._results = None self._results_map = {} self._name_to_manifest = {} self._all_tags = [] self._reduced_results = [] self.last_scan = datetime.datetime(1970, 1, 1) # The Epoch self.debug = debug self.logger = make_logger() if self.debug: self.logger.setLevel(logging.DEBUG) self.logger.debug("Debug logging enabled.") self.host = host self.path = path self.owner = owner self.name = name self.experimentals = experimentals self.dailies = dailies self.weeklies = weeklies self.releases = releases self.recommended = recommended protocol = "https" self.insecure = insecure if self.insecure: protocol = "http" exthost = self.host reghost = exthost if reghost == "hub.docker.com": reghost = "registry.hub.docker.com" if port: exthost += ":" + str(port) reghost += ":" + str(port) self.reghost = reghost self.cachefile = cachefile if self.cachefile: self._read_cachefile() self.registry_url = ( protocol + "://" + reghost + "/v2/" + self.owner + "/" + self.name + "/" ) self.logger.debug("Registry URL: {}".format(self.registry_url)) self.config = RubinConfig() load_k8s_config() self.client = CoreV1Api()
def __init__(self, *args, **kwargs): self.log = make_logger() self.log.debug("Creating {}".format(self.__class__.__name__))