def _set(self, name, val):
if self._row_server_group is None:
self._row_server_group = rhnSQL.Row('rhnServerGroup', 'id')
server_group_id = rhnSQL.Sequence('rhn_server_group_id_seq').next()
self._row_server_group.create(server_group_id)
self._row_server_group[name] = val
def __init__(self, user, arch=None, org_id=None):
ServerWrapper.__init__(self)
self.user = user
# Use the handy TableRow
self.server = rhnSQL.Row("rhnServer", "id")
self.server["release"] = ""
self.server["os"] = "SUSE Linux"
self.addr = {}
self.is_rpm_managed = 0
self.set_arch(arch)
# We only get this passed in when we create a new
# entry. Usually a reload will create a dummy entry first and
# then call self.loadcert()
if user:
self.server["org_id"] = user.customer["id"]
elif org_id:
self.server["org_id"] = org_id
self.cert = None
# Also, at this point we know that this is a real server
self.type = "REAL"
self.default_description()
# custom info values
self.custom_info = None
# uuid
self.uuid = None
self.virt_uuid = None
self.registration_number = None
def _set(self, name, val):
if self._row_reg_token is None:
self._row_reg_token = rhnSQL.Row('rhnRegToken', 'id')
token_id = rhnSQL.Sequence('rhn_reg_token_seq').next()
self._row_reg_token.create(token_id)
self._row_reg_token['usage_limit'] = None
self._row_reg_token[name] = val
def load(self, org_id, name):
org_id = self._lookup_org_id(org_id)
h = rhnSQL.prepare(self._query_lookup)
h.execute(org_id=org_id, name=name)
row = h.fetchone_dict()
if not row:
raise InvalidServerGroupError(org_id, name)
server_group_id = row['id']
self._row_server_group = rhnSQL.Row("rhnServerGroup", 'id')
self._row_server_group.load(server_group_id)
def _save(self):
h = self._row_reg_token
k = 'entitlement_level'
if h.has_key(k):
entitlements = h[k]
del h.data[k]
else:
entitlements = {}
self._row_reg_token.save()
if not self._row_activ_key:
self._row_activ_key = rhnSQL.Row('rhnActivationKey', 'token')
self._row_activ_key.create(self._token)
self._row_activ_key['reg_token_id'] = self._row_reg_token['id']
self._row_activ_key.save()
self._store_server_groups()
self._store_channels()
self._store_entitlements(entitlements)
def __init__(self, hw=None, guest=None):
log_debug(4, hw, guest)
if not hw or "identifier" not in hw or not guest:
# incomplete data
log_debug(1, "incomplete data")
return
host = rhnSQL.Row("rhnServer", "digital_server_id")
host.load(hw['identifier'])
hid = host.get('id')
guest.user = rhnUser.User("", "")
guest.user.reload(guest.server['creator_id'])
guestid = guest.getid()
if not hid:
# create a new host entry
host = server_class.Server(guest.user, hw.get('arch'))
host.server["name"] = hw.get('name')
host.server["os"] = hw.get('os')
host.server["release"] = hw.get('type')
host.server["last_boot"] = time.time()
host.default_description()
host.virt_type = rhnVirtualization.VirtualizationType.FULLY
host.virt_uuid = None
fake_token = False
if not rhnFlags.test("registration_token"):
# we need to fake it
rhnFlags.set("registration_token", 'fake')
fake_token = True
host.save(1, None)
host.server["digital_server_id"] = hw['identifier']
entitle_server = rhnSQL.Procedure(
"rhn_entitlements.entitle_server")
entitle_server(host.getid(), 'foreign_entitled')
host.save(1, None)
if fake_token:
rhnFlags.set("registration_token", None)
hid = host.getid()
host.reload(hid)
log_debug(4, "New host created: ", host)
else:
host = server_class.Server(None)
host.reload(hid)
host.checkin(commit=0)
log_debug(4, "Found host: ", host)
host.reload_hardware()
hostcpu = host.hardware_by_class(CPUDevice)
if hostcpu and len(hostcpu) > 0:
hostcpu = hostcpu[0].data
else:
hostcpu = None
if not hostcpu or str(hostcpu.get('nrsocket')) != hw.get('total_ifls'):
# update only if the number has changed
log_debug(1, "update host cpu:", hw.get('total_ifls'))
cpu = {
'class': 'CPU',
'desc': 'Processor',
'count': hw.get('total_ifls'),
'model_ver': '',
'speed': '0',
'cache': '',
'model_number': '',
'bogomips': '',
'socket_count': hw.get('total_ifls'),
'platform': hw.get('arch'),
'other': '',
'model_rev': '',
'model': hw.get('arch'),
'type': hw.get('type')
}
host.delete_hardware()
host.add_hardware(cpu)
host.save_hardware()
h = rhnSQL.prepare("""
select host_system_id
from rhnVirtualInstance
where virtual_system_id = :guestid""")
h.execute(guestid=guestid)
row = h.fetchone_dict()
if not row or not row['host_system_id']:
self._insert_virtual_instance(hid, None, fakeuuid=False)
self._insert_virtual_instance(hid, guestid, fakeuuid=True)
elif row['host_system_id'] != hid:
log_debug(4, "update_virtual_instance", hid, guestid)
q_update = rhnSQL.prepare("""
UPDATE rhnVirtualInstance
SET host_system_id = :host_id
WHERE virtual_system_id = :guest_id
AND host_system_id = :old_host_id
""")
q_update.execute(host_id=hid,
guest_id=guestid,
old_host_id=row['host_system_id'])
