def log_into_node(self, node, username=None, password=None,
r_username=None, r_password=None):
"""
Raises IOError.
"""
rc = False # assume failure
msg = ""
try:
authinfo = None
if username or password or r_username or r_password:
# may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=username,
password=password,
reverse_username=r_username,
reverse_password=r_password)
node.setAuth(authinfo)
node.login()
rc = True
log.info("iSCSI: logged into %s at %s:%s through %s",
node.name, node.address, node.port, node.iface)
if not self._mark_node_active(node):
log.error("iSCSI: node not found among discovered")
except (IOError, ValueError) as e:
msg = str(e)
log.warning("iSCSI: could not log into %s: %s", node.name, msg)
return (rc, msg)
def log_into_node(self, node, username=None, password=None,
r_username=None, r_password=None, intf=None):
"""
Raises IOError.
"""
rc = False # assume failure
msg = ""
if intf:
w = intf.waitWindow(_("Logging in to iSCSI node"),
_("Logging in to iSCSI node %s") % node.name)
try:
authinfo = None
if username or password or r_username or r_password:
# may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=username,
password=password,
reverse_username=r_username,
reverse_password=r_password)
node.setAuth(authinfo)
node.login()
rc = True
log.info("iSCSI: logged into %s %s:%s" % (node.name,
node.address,
node.port))
self.nodes.append(node)
except (IOError, ValueError) as e:
msg = str(e)
log.warning("iSCSI: could not log into %s: %s" % (node.name, msg))
if intf:
w.pop()
return (rc, msg)
def log_into_node(self,
node,
username=None,
password=None,
r_username=None,
r_password=None):
"""
Raises IOError.
"""
rc = False # assume failure
msg = ""
try:
authinfo = None
if username or password or r_username or r_password:
# may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=username,
password=password,
reverse_username=r_username,
reverse_password=r_password)
node.setAuth(authinfo)
node.login()
rc = True
log.info("iSCSI: logged into %s at %s:%s through %s", node.name,
node.address, node.port, node.iface)
if not self._mark_node_active(node):
log.error("iSCSI: node not found among discovered")
except (IOError, ValueError) as e:
msg = str(e)
log.warning("iSCSI: could not log into %s: %s", node.name, msg)
return (rc, msg)
def discover(self, ipaddr, port="3260", username=None, password=None,
r_username=None, r_password=None, intf=None):
"""
Discover iSCSI nodes on the target.
Returns list of new found nodes.
"""
authinfo = None
found = 0
logged_in = 0
if not has_iscsi():
raise IOError, _("iSCSI not available")
if self._initiator == "":
raise ValueError, _("No initiator name set")
if username or password or r_username or r_password:
# Note may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=username,
password=password,
reverse_username=r_username,
reverse_password=r_password)
self.startup(intf)
# Note may raise an IOError
found_nodes = libiscsi.discover_sendtargets(address=ipaddr,
port=int(port),
authinfo=authinfo)
# only return the nodes we are not logged into yet
return [n for n in found_nodes if n not in self.nodes]
def discover(self,
ipaddr,
port="3260",
username=None,
password=None,
r_username=None,
r_password=None,
intf=None):
"""
Discover iSCSI nodes on the target available for login.
If we are logged in a node discovered for specified target
do not do the discovery again as it can corrupt credentials
stored for the node (setAuth and getAuth are using database
in /var/lib/iscsi/nodes which is filled by discovery). Just
return nodes obtained and stored in the first discovery
instead.
Returns list of nodes user can log in.
"""
authinfo = None
if not has_iscsi():
raise IOError, _("iSCSI not available")
if self._initiator == "":
raise ValueError, _("No initiator name set")
if self.active_nodes((ipaddr, port)):
log.debug(
"iSCSI: skipping discovery of %s:%s due to active nodes" %
(ipaddr, port))
else:
if username or password or r_username or r_password:
# Note may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=username,
password=password,
reverse_username=r_username,
reverse_password=r_password)
self.startup(intf)
# Note may raise an IOError
found_nodes = libiscsi.discover_sendtargets(address=ipaddr,
port=int(port),
authinfo=authinfo)
if found_nodes is None:
return None
self.discovered_targets[(ipaddr, port)] = []
for node in found_nodes:
self.discovered_targets[(ipaddr, port)].append([node, False])
log.debug("discovered iSCSI node: %s" % node.name)
# only return the nodes we are not logged into yet
return [
node
for (node, logged_in) in self.discovered_targets[(ipaddr, port)]
if not logged_in
]
def addTarget(self,
ipaddr,
port="3260",
user=None,
pw=None,
user_in=None,
pw_in=None,
intf=None):
authinfo = None
found = 0
logged_in = 0
if not has_iscsi():
raise IOError, _("iSCSI not available")
if self._initiator == "":
raise ValueError, _("No initiator name set")
if user or pw or user_in or pw_in:
# Note may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=user,
password=pw,
reverse_username=user_in,
reverse_password=pw_in)
self.startup(intf)
# Note may raise an IOError
found_nodes = libiscsi.discover_sendtargets(address=ipaddr,
port=int(port),
authinfo=authinfo)
if found_nodes == None:
raise IOError, _("No iSCSI nodes discovered")
if intf:
w = intf.waitWindow(_("Logging in to iSCSI nodes"),
_("Logging in to iSCSI nodes"))
for node in found_nodes:
# skip nodes we already have
if node in self.nodes:
continue
found = found + 1
try:
if (authinfo):
node.setAuth(authinfo)
node.login()
log.info("iscsi.addTarget logged in to %s %s %s" %
(node.name, node.address, node.port))
self.nodes.append(node)
logged_in = logged_in + 1
except IOError, e:
log.warning(
"Could not log into discovered iscsi target %s: %s" %
(node.name, str(e)))
# some nodes may require different credentials
pass
def addTarget(self, ipaddr, port="3260", user=None, pw=None,
user_in=None, pw_in=None, intf=None):
authinfo = None
found = 0
logged_in = 0
if not has_iscsi():
raise IOError, _("iSCSI not available")
if self._initiator == "":
raise ValueError, _("No initiator name set")
if user or pw or user_in or pw_in:
# Note may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=user, password=pw,
reverse_username=user_in,
reverse_password=pw_in)
self.startup(intf)
# Note may raise an IOError
found_nodes = libiscsi.discover_sendtargets(address=ipaddr,
port=int(port),
authinfo=authinfo)
if found_nodes == None:
raise IOError, _("No iSCSI nodes discovered")
if intf:
w = intf.waitWindow(_("Logging in to iSCSI nodes"),
_("Logging in to iSCSI nodes"))
for node in found_nodes:
# skip nodes we already have
if node in self.nodes:
continue
found = found + 1
try:
if (authinfo):
node.setAuth(authinfo)
node.login()
self.nodes.append(node)
logged_in = logged_in + 1
except:
# some nodes may require different credentials
pass
if intf:
w.pop()
if found == 0:
raise IOError, _("No new iSCSI nodes discovered")
if logged_in == 0:
raise IOError, _("Could not log in to any of the discovered nodes")
stabilize(intf)
def discover(self, ipaddr, port="3260", username=None, password=None,
r_username=None, r_password=None):
"""
Discover iSCSI nodes on the target available for login.
If we are logged in a node discovered for specified target
do not do the discovery again as it can corrupt credentials
stored for the node (setAuth and getAuth are using database
in /var/lib/iscsi/nodes which is filled by discovery). Just
return nodes obtained and stored in the first discovery
instead.
Returns list of nodes user can log in.
"""
authinfo = None
if not has_iscsi():
raise IOError, _("iSCSI not available")
if self._initiator == "":
raise ValueError, _("No initiator name set")
if self.active_nodes((ipaddr, port)):
log.debug("iSCSI: skipping discovery of %s:%s due to active nodes" %
(ipaddr, port))
else:
if username or password or r_username or r_password:
# Note may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=username,
password=password,
reverse_username=r_username,
reverse_password=r_password)
self.startup()
# Note may raise an IOError
found_nodes = libiscsi.discover_sendtargets(address=ipaddr,
port=int(port),
authinfo=authinfo)
if found_nodes is None:
return []
self.discovered_targets[(ipaddr, port)] = []
for node in found_nodes:
self.discovered_targets[(ipaddr, port)].append([node, False])
log.debug("discovered iSCSI node: %s" % node.name)
# only return the nodes we are not logged into yet
return [node for (node, logged_in) in
self.discovered_targets[(ipaddr, port)]
if not logged_in]
def log_into_node(self,
node,
username=None,
password=None,
r_username=None,
r_password=None,
intf=None):
"""
Raises IOError.
"""
rc = False # assume failure
msg = ""
if intf:
w = intf.waitWindow(_("Logging in to iSCSI node"),
_("Logging in to iSCSI node %s") % node.name)
try:
authinfo = None
if username or password or r_username or r_password:
# may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=username,
password=password,
reverse_username=r_username,
reverse_password=r_password)
node.setAuth(authinfo)
node.login()
rc = True
log.info("iSCSI: logged into %s at %s:%s through %s" %
(node.name, node.address, node.port, node.iface))
self.nodes.append(node)
except (IOError, ValueError) as e:
msg = str(e)
log.warning("iSCSI: could not log into %s: %s" % (node.name, msg))
if intf:
w.pop()
return (rc, msg)
def discover(self,
ipaddr,
port="3260",
username=None,
password=None,
r_username=None,
r_password=None,
intf=None):
"""
Discover iSCSI nodes on the target.
Returns list of new found nodes.
"""
authinfo = None
found = 0
logged_in = 0
if not has_iscsi():
raise IOError, _("iSCSI not available")
if self._initiator == "":
raise ValueError, _("No initiator name set")
if username or password or r_username or r_password:
# Note may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=username,
password=password,
reverse_username=r_username,
reverse_password=r_password)
self.startup(intf)
# Note may raise an IOError
found_nodes = libiscsi.discover_sendtargets(address=ipaddr,
port=int(port),
authinfo=authinfo)
# only return the nodes we are not logged into yet
return [n for n in found_nodes if n not in self.nodes]
def discover(self, ipaddr, port="3260", username=None, password=None,
r_username=None, r_password=None):
"""
Discover iSCSI nodes on the target available for login.
If we are logged in a node discovered for specified target
do not do the discovery again as it can corrupt credentials
stored for the node (setAuth and getAuth are using database
in /var/lib/iscsi/nodes which is filled by discovery). Just
return nodes obtained and stored in the first discovery
instead.
Returns list of nodes user can log in.
"""
authinfo = None
if not has_iscsi():
raise IOError(_("iSCSI not available"))
if self._initiator == "":
raise ValueError(_("No initiator name set"))
if self.active_nodes((ipaddr, port)):
log.debug("iSCSI: skipping discovery of %s:%s due to active nodes",
ipaddr, port)
else:
if username or password or r_username or r_password:
# Note may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=username,
password=password,
reverse_username=r_username,
reverse_password=r_password)
self.startup()
# start libiscsi discover_sendtargets in a new process
# threads can't be used here because the libiscsi library
# using signals internally which are send to bad thread
(con_recv, con_write) = Pipe(False)
p = Process(target=_call_discover_targets, args=(con_write,
con_recv,
ipaddr,
port,
authinfo, ))
p.start()
# Close the writing end of the pipe in the parent
con_write.close()
with con_recv:
try:
(ok, data) = con_recv.recv()
if not ok:
log.debug("iSCSI: exception raised when "
"discover_sendtargets process called: %s",
str(data))
except EOFError:
ok = False
log.error("iSCSI: can't receive response from "
"_call_discover_targets")
p.join()
# convert dictionary back to iscsi nodes object
if ok:
found_nodes = []
for node in data:
found_nodes.append(libiscsi.node(**node))
else:
return []
self.discovered_targets[(ipaddr, port)] = []
for node in found_nodes:
self.discovered_targets[(ipaddr, port)].append([node, False])
log.debug("discovered iSCSI node: %s", node.name)
# only return the nodes we are not logged into yet
return [node for (node, logged_in) in
self.discovered_targets[(ipaddr, port)]
if not logged_in]
def discover(self, ipaddr, port="3260", username=None, password=None,
r_username=None, r_password=None):
"""
Discover iSCSI nodes on the target available for login.
If we are logged in a node discovered for specified target
do not do the discovery again as it can corrupt credentials
stored for the node (setAuth and getAuth are using database
in /var/lib/iscsi/nodes which is filled by discovery). Just
return nodes obtained and stored in the first discovery
instead.
Returns list of nodes user can log in.
"""
authinfo = None
if not has_iscsi():
raise IOError(_("iSCSI not available"))
if self._initiator == "":
raise ValueError(_("No initiator name set"))
if self.active_nodes((ipaddr, port)):
log.debug("iSCSI: skipping discovery of %s:%s due to active nodes",
ipaddr, port)
else:
if username or password or r_username or r_password:
# Note may raise a ValueError
authinfo = libiscsi.chapAuthInfo(username=username,
password=password,
reverse_username=r_username,
reverse_password=r_password)
self.startup()
# start libiscsi discover_sendtargets in a new process
# threads can't be used here because the libiscsi library
# using signals internally which are send to bad thread
(con_recv, con_write) = Pipe(False)
p = Process(target=_call_discover_targets, args=(con_write,
ipaddr,
port,
authinfo, ))
p.start()
try:
(ok, data) = con_recv.recv()
if not ok:
log.debug("iSCSI: exception raised when "
"discover_sendtargets process called: %s",
str(data))
except EOFError:
ok = False
log.error("iSCSI: can't receive response from "
"_call_discover_targets")
p.join()
# convert dictionary back to iscsi nodes object
if ok:
found_nodes = []
for node in data:
found_nodes.append(libiscsi.node(**node))
else:
return []
self.discovered_targets[(ipaddr, port)] = []
for node in found_nodes:
self.discovered_targets[(ipaddr, port)].append([node, False])
log.debug("discovered iSCSI node: %s", node.name)
# only return the nodes we are not logged into yet
return [node for (node, logged_in) in
self.discovered_targets[(ipaddr, port)]
if not logged_in]
