def __init__(self, name, reference, binary_path, scratch_path): if not isinstance(name, basestring): raise IncorrectTypeError( RemoteHost, 'name', type(name), basestring) self.__name = name if not isinstance(reference, basestring): raise IncorrectTypeError( RemoteHost, 'reference', type(reference), basestring) self.__reference = reference if not isinstance(binary_path, basestring): raise IncorrectTypeError( RemoteHost, 'binary_path', type(binary_path), basestring) self.__binary_path = binary_path if not isinstance(scratch_path, basestring): raise IncorrectTypeError( RemoteHost, 'scratch_path', type(scratch_path), basestring) self.__scratch_path = scratch_path
def __init__(self, name, reference): if not isinstance(name, basestring): raise IncorrectTypeError(RemoteUser, 'name', type(name), basestring) self.__name = name if not isinstance(reference, basestring): raise IncorrectTypeError(RemoteUser, 'reference', type(reference), basestring) self.__reference = reference
def __init__(self, uid, gid): if not isinstance(uid, int): raise IncorrectTypeError(OwnershipSpecification, 'uid', type(uid), int) self._uid = uid if not isinstance(gid, int): raise IncorrectTypeError(OwnershipSpecification, 'gid', type(gid), int) self._gid = gid
def __init__(self, username, private_key, public_key): super(KeyPairCredentials, self).__init__(username) if not isinstance(private_key, basestring): raise IncorrectTypeError(KeyPairCredentials, 'private_key', type(private_key), basestring) self.__private_key = private_key if not isinstance(public_key, basestring): raise IncorrectTypeError(KeyPairCredentials, 'public_key', type(public_key), basestring) self.__public_key = public_key
def __init__(self, remote_environment, mount_path, shared_path=None): """A Mount object asks for multiple Python objects (RemoteEnvironment, RemoteHost), which have parameters (such as name, binary_path and scratch_path) that require the plugin writer to provide values for. Plugin writers will not know the values for these, nor are these values ever used by engine code, except for RemoteHost's reference parameter. This check allows plugin writers to provide either a RemoteEnvironment object with fully populated parameters, or a reference string, leaving the other parameters to be populated with dummy values. This saves the plugin writer from attempting to provide parameter values that they won't have access to.""" def __is_correct_reference_format(reference): unix_format = re.compile("^UNIX_HOST_ENVIRONMENT-\d+$") win_format = re.compile("^WINDOWS_HOST_ENVIRONMENT-\d+$") return bool(unix_format.match(reference)) or \ bool(win_format.match(reference)) def __make_remote_environment_from_reference(reference): dummy_host = RemoteHost("dummy host", "dummy reference", "dummy binary path", "dummy scratch path") if not isinstance(remote_environment, RemoteEnvironment) and not \ __is_correct_reference_format(remote_environment): raise RuntimeError( "Reference '{}' is not a valid host environment reference." .format(reference)) return RemoteEnvironment("dummy name", reference, dummy_host) # if reference is not a RemoteEnvironment nor a string if not isinstance(remote_environment, RemoteEnvironment) and not \ isinstance(remote_environment, six.string_types): raise IncorrectTypeError(Mount, 'remote_environment', type(remote_environment), [RemoteEnvironment, six.string_types[0]]) # if reference is a string, but incorrectly formatted if isinstance( remote_environment, six.string_types ) and not __is_correct_reference_format(remote_environment): raise IncorrectReferenceFormatError(remote_environment) # If the plugin has provided us with just a valid reference string, # convert to a real Python object if isinstance(remote_environment, six.string_types): self._remote_environment = __make_remote_environment_from_reference( remote_environment) else: self._remote_environment = remote_environment if not isinstance(mount_path, six.string_types): raise IncorrectTypeError(Mount, 'mount_path', type(mount_path), six.string_types[0]) self._mount_path = mount_path if shared_path and not isinstance(shared_path, six.string_types[0]): raise IncorrectTypeError(Mount, 'shared_path', type(shared_path), six.string_types[0], False) self._shared_path = shared_path
def __init__(self, environment, user): if isinstance(environment, RemoteEnvironment): self.__environment = environment else: raise IncorrectTypeError(RemoteConnection, 'environment', type(environment), RemoteEnvironment) if isinstance(user, RemoteUser): self.__user = user else: raise IncorrectTypeError(RemoteConnection, 'user', type(user), RemoteUser)
def __init__(self, guid, source_connection, parameters, mount, staged_connection): self._guid = guid if not isinstance(source_connection, RemoteConnection): raise IncorrectTypeError(RemoteConnection, 'source_connection', type(source_connection), RemoteConnection) self._source_connection = source_connection self._parameters = parameters self._mount = mount if not isinstance(staged_connection, RemoteConnection): raise IncorrectTypeError(RemoteConnection, 'staged_connection', type(staged_connection), RemoteConnection) self._staged_connection = staged_connection
def __init__(self, name, reference, host): if not isinstance(name, basestring): raise IncorrectTypeError(RemoteEnvironment, 'name', type(name), basestring) self.__name = name if not isinstance(reference, basestring): raise IncorrectTypeError(RemoteEnvironment, 'reference', type(reference), basestring) self.__reference = reference if isinstance(host, RemoteHost): self.host = host else: raise IncorrectTypeError(RemoteEnvironment, 'host', type(host), RemoteHost)
def __init__(self, guid, connection, parameters): self._guid = guid if not isinstance(connection, RemoteConnection): raise IncorrectTypeError(RemoteConnection, 'connection', type(connection), RemoteConnection) self._connection = connection self._parameters = parameters
def from_proto(user): """Converts protobuf class common_pb2.RemoteUser to plugin class RemoteUser """ if not isinstance(user, common_pb2.RemoteUser): raise IncorrectTypeError(RemoteUser, 'user', type(user), common_pb2.RemoteUser) remote_user = RemoteUser(name=user.name, reference=user.reference) return remote_user
def __init__(self, mounts, ownership_specification=None): if not isinstance(mounts, list): raise IncorrectTypeError(MountSpecification, 'mounts', type(mounts), [Mount]) if not all(isinstance(mount, Mount) for mount in mounts): raise IncorrectTypeError(MountSpecification, 'mounts', [type(mount) for mount in mounts], [Mount]) self._mounts = mounts if (ownership_specification and not isinstance( ownership_specification, OwnershipSpecification)): raise IncorrectTypeError(MountSpecification, 'ownership_specification', type(ownership_specification), OwnershipSpecification, False) self._ownership_specification = ownership_specification
def __init__(self, remote_environment, mount_path, shared_path=None): if not isinstance(remote_environment, RemoteEnvironment): raise IncorrectTypeError( Mount, 'remote_environment', type(remote_environment), RemoteEnvironment) self._remote_environment = remote_environment if not isinstance(mount_path, basestring): raise IncorrectTypeError( Mount, 'mount_path', type(mount_path), basestring) self._mount_path = mount_path if shared_path and not isinstance(shared_path, basestring): raise IncorrectTypeError( Mount, 'shared_path', type(shared_path), basestring, False) self._shared_path = shared_path
def from_proto(credentials_result): """Converts protobuf class libs_pb2.CredentialsResult to plugin class PasswordCredentials """ if not isinstance(credentials_result, libs_pb2.CredentialsResult): raise IncorrectTypeError(PasswordCredentials, 'credentials_result', type(credentials_result), libs_pb2.CredentialsResult) return PasswordCredentials(username=credentials_result.username, password=credentials_result.pasword)
def from_proto(connection): """Converts protobuf class common_pb2.RemoteConnection to plugin class RemoteConnection """ if not isinstance(connection, common_pb2.RemoteConnection): raise IncorrectTypeError(RemoteConnection, 'connection', type(connection), common_pb2.RemoteConnection) environment = RemoteEnvironment.from_proto(connection.environment) user = RemoteUser.from_proto(connection.user) return RemoteConnection(environment=environment, user=user)
def from_proto(environment): """Converts protobuf class common_pb2.RemoteEnvironment to plugin class RemoteEnvironment """ if not isinstance(environment, common_pb2.RemoteEnvironment): raise IncorrectTypeError(RemoteEnvironment, 'environment', type(environment), common_pb2.RemoteEnvironment) return RemoteEnvironment(name=environment.name, reference=environment.reference, host=RemoteHost.from_proto(environment.host))
def from_proto(host): """Converts protobuf class common_pb2.RemoteHost to plugin class RemoteHost """ if not isinstance(host, common_pb2.RemoteHost): raise IncorrectTypeError(RemoteHost, 'host', type(host), common_pb2.RemoteHost) return RemoteHost(name=host.name, reference=host.reference, binary_path=host.binary_path, scratch_path=host.scratch_path)
def from_proto(credentials_result): """Converts protobuf class libs_pb2.CredentialsResult to plugin class KeyPairCredentials """ if not isinstance(credentials_result, libs_pb2.CredentialsResult): raise IncorrectTypeError(KeyPairCredentials, 'credentials_result', type(credentials_result), libs_pb2.CredentialsResult) return KeyPairCredentials( username=credentials_result.username, private_key=credentials_result.key_pair.private_key, public_key=credentials_result.key_pair.public_key)
def __init__(self, username, password): super(PasswordCredentials, self).__init__(username) if not isinstance(password, basestring): raise IncorrectTypeError(PasswordCredentials, 'password', type(password), basestring) self.__password = password
def __init__(self, username): if not isinstance(username, basestring): raise IncorrectTypeError(Credentials, 'username', type(username), basestring) self.__username = username