def test_getaddrinfo_fallback(self): """ C{get_fqdn} falls back to C{socket.getaddrinfo} with the C{AI_CANONNAME} flag if C{socket.getfqdn} returns a local hostname. """ self.addCleanup(setattr, socket, "getfqdn", socket.getfqdn) socket.getfqdn = lambda: "localhost6.localdomain6" self.assertNotIn("localhost", get_fqdn())
def test_default_fqdn(self): """ C{get_fqdn} returns the output of C{socket.getfqdn} if it returns something sensible. """ self.addCleanup(setattr, socket, "getfqdn", socket.getfqdn) socket.getfqdn = lambda: "foo.bar" self.assertEqual("foo.bar", get_fqdn())
def _handle_pre_exchange(self): """ An exchange is about to happen. If we don't have a secure id already set, and we have the needed information available, queue a registration message with the server. """ # The point of storing this flag is that if we should *not* register # now, and then after the exchange we *should*, we schedule an urgent # exchange again. Without this flag we would just spin trying to # connect to the server when something is clearly preventing the # registration. self._should_register = self.should_register() if not self._should_register: return # These are just to shorten the code. identity = self._identity account_name = identity.account_name if not account_name: self._reactor.fire("registration-failed", reason="unknown-account") return tags = identity.tags group = identity.access_group registration_key = identity.registration_key self._message_store.delete_all_messages() if not is_valid_tag_list(tags): tags = None logging.error("Invalid tags provided for registration.") message = { "type": "register", "hostname": get_fqdn(), "account_name": account_name, "computer_title": identity.computer_title, "registration_password": identity.registration_key, "tags": tags, "container-info": get_container_info(), "vm-info": get_vm_info() } if self._clone_secure_id: # We use the secure id here because the registration is encrypted # and the insecure id has been already exposed to unencrypted # http from the ping server. In addition it's more straightforward # to get the computer from the server through it than the insecure message["clone_secure_id"] = self._clone_secure_id if group: message["access_group"] = group server_api = self._message_store.get_server_api() # If we have juju data to send and if the server is recent enough to # know how to handle juju data, then we include it in the registration # message. We want to trigger the 3.3 server handler because client # version 14.01 has a different format for the juju-info field, # so this makes sure that the correct schema is used by the server # when validating our message. if self._juju_data and is_version_higher(server_api, b"3.3"): message["juju-info"] = { "environment-uuid": self._juju_data["environment-uuid"], "api-addresses": self._juju_data["api-addresses"], "machine-id": self._juju_data["machine-id"] } # The computer is a normal computer, possibly a container. with_word = "with" if bool(registration_key) else "without" with_tags = "and tags %s " % tags if tags else "" with_group = "in access group '%s' " % group if group else "" logging.info(u"Queueing message to register with account %r %s%s" "%s a password." % (account_name, with_group, with_tags, with_word)) self._exchange.send(message)
LOCAL_ACCOUNT_NAME = "standalone" HOSTED_PASSWORD = "" LOCAL_PASSWORD = "" HOSTED = "hosted" LOCAL = "local" MANAGEMENT_TYPE = "management-type" COMPUTER_TITLE = "computer-title" LANDSCAPE_HOST = "landscape-host" ACCOUNT_NAME = "account-name" PASSWORD = "******" DEFAULT_DATA = { MANAGEMENT_TYPE: NOT_MANAGED, COMPUTER_TITLE: get_fqdn(), HOSTED: { LANDSCAPE_HOST: HOSTED_LANDSCAPE_HOST, ACCOUNT_NAME: HOSTED_ACCOUNT_NAME, PASSWORD: HOSTED_PASSWORD }, LOCAL: { LANDSCAPE_HOST: LOCAL_LANDSCAPE_HOST, ACCOUNT_NAME: LOCAL_ACCOUNT_NAME, PASSWORD: LOCAL_PASSWORD } } def derive_server_host_name_from_url(url): """