public static void handleApplicationClustersCreated(String appId, List<Cluster> appClusters) { TopologyManager.acquireWriteLock(); try { Topology topology = TopologyManager.getTopology(); for (Cluster cluster : appClusters) { Service service = topology.getService(cluster.getServiceName()); if (service == null) { log.error( "Service " + cluster.getServiceName() + " not found in Topology, unable to create Application cluster"); } else { service.addCluster(cluster); log.info("Application Cluster " + cluster.getClusterId() + " created in CC topology"); } } TopologyManager.updateTopology(topology); } finally { TopologyManager.releaseWriteLock(); } log.debug("Creating cluster port mappings: [appication-id] " + appId); for (Cluster cluster : appClusters) { String cartridgeType = cluster.getServiceName(); Cartridge cartridge = CloudControllerContext.getInstance().getCartridge(cartridgeType); if (cartridge == null) { throw new CloudControllerException( "Cartridge not found: [cartridge-type] " + cartridgeType); } for (PortMapping portMapping : cartridge.getPortMappings()) { ClusterPortMapping clusterPortMapping = new ClusterPortMapping( appId, cluster.getClusterId(), portMapping.getName(), portMapping.getProtocol(), portMapping.getPort(), portMapping.getProxyPort()); if (portMapping.getKubernetesPortType() != null) { clusterPortMapping.setKubernetesServiceType(portMapping.getKubernetesPortType()); } CloudControllerContext.getInstance().addClusterPortMapping(clusterPortMapping); log.debug("Cluster port mapping created: " + clusterPortMapping.toString()); } } // Persist cluster port mappings CloudControllerContext.getInstance().persist(); // Send application clusters created event TopologyEventPublisher.sendApplicationClustersCreated(appId, appClusters); }
/** * Performs a CPU address space write. Maps all of the relevant object into the right parts of * memory. */ public final void addressWrite(int addr, int data) { switch (addr & 0xF000) { case 0x0000: case 0x1000: case 0x2000: case 0x3000: case 0x4000: case 0x5000: case 0x6000: case 0x7000: if (!running) { cartridge.debuggerAddressWrite(addr, data); } else { cartridge.addressWrite(addr, data); } break; case 0x8000: case 0x9000: graphicsChip.addressWrite(addr - 0x8000, (byte) data); break; case 0xA000: case 0xB000: cartridge.addressWrite(addr, data); break; case 0xC000: mainRam[addr - 0xC000] = (byte) data; break; case 0xD000: mainRam[addr - 0xD000 + (gbcRamBank * 0x1000)] = (byte) data; break; case 0xE000: mainRam[addr - 0xE000] = (byte) data; break; case 0xF000: if (addr < 0xFE00) { try { mainRam[addr - 0xE000] = (byte) data; } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Address error: " + addr + " pc = " + JavaBoy.hexWord(pc)); } } else if (addr < 0xFF00) { oam[addr - 0xFE00] = (byte) data; } else { ioHandler.ioWrite(addr - 0xFF00, (short) data); } break; } }
/** thread's run() method that does all the work in the right order */ public void run() { try { if (log != null) log.println( "-------------------\ncartridge " + gwcfile.name + " started (openWIG r" + VERSION + ")\n-------------------"); prepareState(); if (doRestore) restoreGame(); else newGame(); loglevel = LOG_PROP; ui.debugMsg("Starting game...\n"); ui.start(); player.refreshLocation(); cartridge.callEvent(doRestore ? "OnRestore" : "OnStart", null); ui.refresh(); eventRunner.unpause(); mainloop(); } catch (IOException e) { ui.showError("Could not load cartridge: " + e.getMessage()); } catch (Throwable t) { stacktrace(t); } finally { ui.end(); } }
/** main loop - periodically copy location data into Lua and evaluate zone positions */ private void mainloop() { try { while (!end) { try { if (gps.getLatitude() != player.position.latitude || gps.getLongitude() != player.position.longitude || gps.getAltitude() != player.position.altitude) { player.refreshLocation(); } cartridge.tick(); } catch (Exception e) { stacktrace(e); } try { Thread.sleep(1000); } catch (InterruptedException e) { } } if (log != null) log.close(); } catch (Throwable t) { ui.end(); stacktrace(t); } finally { instance = null; state = null; if (eventRunner != null) eventRunner.kill(); eventRunner = null; } }
/** Resets the CPU to it's power on state. Memory contents are not cleared. */ public void reset() { checkEnableGbc(); setDoubleSpeedCpu(false); graphicsChip.dispose(); cartridge.reset(); interruptsEnabled = false; ieDelay = -1; pc = 0x0100; sp = 0xFFFE; f = 0xB0; gbcRamBank = 1; instrCount = 0; if (gbcFeatures) { registers[a] = 0x11; } else { registers[a] = 0x01; } for (int r = 0; r < 0x8000; r++) { mainRam[r] = 0; } setBC(0x0013); setDE(0x00D8); setHL(0x014D); JavaBoy.debugLog("CPU reset"); ioHandler.reset(); }
/** Execute the specified number of Gameboy instructions. Use '-1' to execute forever */ public final void execute(int numInstr) { terminate = false; running = true; graphicsChip.startTime = System.currentTimeMillis(); int b1, b2, b3, offset; long t; for (int r = 0; (r != numInstr) && (!terminate); r++) { t = System.currentTimeMillis(); instrCount++; b1 = JavaBoy.unsign(addressRead(pc)); offset = addressRead(pc + 1); b3 = JavaBoy.unsign(addressRead(pc + 2)); b2 = JavaBoy.unsign((short) offset); // stats.addExecution(b1); instructionManager.execute(b1, b2, b3, offset); if (ieDelay != -1) { if (ieDelay > 0) { ieDelay--; } else { interruptsEnabled = true; ieDelay = -1; } } if (interruptsEnabled) { checkInterrupts(); } cartridge.update(); initiateInterrupts(); if ((t - initialTime) > checkpointTime) { initialTime = t; saveCheckpointInterrupt = true; } if (saveInterrupt) { saveState(".stsv"); saveInterrupt = false; } if (loadStateInterrupt) { loadState(".stsv"); loadStateInterrupt = false; } if (saveCheckpointInterrupt) { saveState(".cksv"); saveCheckpointInterrupt = false; } if (loadCheckpointInterrupt) { loadState(".cksv"); loadCheckpointInterrupt = false; } } running = false; terminate = false; }
public void saveState(String extension) { String directory = (cartridge.romFileName + extension); try { FileOutputStream fl = new FileOutputStream(directory); DataOutputStream sv = new DataOutputStream(fl); saveData(sv, directory); // write battery ram cartridge.saveData(sv, directory); // write graphic memory graphicsChip.saveData(sv, directory); // write io state ioHandler.saveData(sv, directory); // stats.printStats(); sv.close(); fl.close(); } catch (FileNotFoundException e) { System.out.println("Dmgcpu.saveState: Could not open file " + directory); System.out.println("Error Message: " + e.getMessage()); System.exit(-1); } catch (IOException e) { System.out.println("Dmgcpu.saveState: Could not write to file " + directory); System.out.println("Error Message: " + e.getMessage()); System.exit(-1); } System.out.println("Saved stage!"); }
/** * Perform a CPU address space read. This maps all the relevant objects into the correct parts of * the memory */ public final short addressRead(int addr) { addr = addr & 0xFFFF; switch ((addr & 0xF000)) { case 0x0000: case 0x1000: case 0x2000: case 0x3000: case 0x4000: case 0x5000: case 0x6000: case 0x7000: return cartridge.addressRead(addr); case 0x8000: case 0x9000: return graphicsChip.addressRead(addr - 0x8000); case 0xA000: case 0xB000: return cartridge.addressRead(addr); case 0xC000: return (mainRam[addr - 0xC000]); case 0xD000: return (mainRam[addr - 0xD000 + (gbcRamBank * 0x1000)]); case 0xE000: return mainRam[addr - 0xE000]; case 0xF000: if (addr < 0xFE00) { return mainRam[addr - 0xE000]; } else if (addr < 0xFF00) { return (short) (oam[addr - 0xFE00] & 0x00FF); } else { return ioHandler.ioRead(addr - 0xFF00); } default: System.out.println("Tried to read address " + addr + ". pc = " + JavaBoy.hexWord(pc)); return 0xFF; } }
public static void handleServiceRemoved(List<Cartridge> cartridgeList) { Topology topology = TopologyManager.getTopology(); for (Cartridge cartridge : cartridgeList) { Service service = topology.getService(cartridge.getType()); if (service == null) { log.warn("Cartridge does not exist [cartidge] " + cartridge); return; } if (service.getClusters().size() == 0) { if (topology.serviceExists(cartridge.getType())) { try { TopologyManager.acquireWriteLock(); topology.removeService(cartridge.getType()); TopologyManager.updateTopology(topology); } finally { TopologyManager.releaseWriteLock(); } TopologyEventPublisher.sendServiceRemovedEvent(cartridgeList); } else { log.warn(String.format("Service %s does not exist..", cartridge.getType())); } } else { log.warn( "Subscription already exists. Hence not removing the service:" + cartridge.getType() + " from the topology"); } } }
public void loadState(String extension) { String directory = cartridge.romFileName + extension; try { reset(); FileInputStream fl = new FileInputStream(directory); DataInputStream sv = new DataInputStream(fl); // write cpu data loadData(sv, directory); // write battery ram cartridge.loadData(sv, directory); // write graphic memory graphicsChip.loadData(sv, directory); // writes io state ioHandler.loadData(sv, directory); sv.close(); fl.close(); } catch (FileNotFoundException ex) { System.out.println("Dmgcpu.loadState: Could not open file " + directory); System.out.println("Error Message: " + ex.getMessage()); System.exit(-1); } catch (IOException ex) { System.out.println("Dmgcpu.loadState: Could not read file " + directory); System.out.println("Error Message: " + ex.getMessage()); System.exit(-1); } System.out.println("Loaded stage!"); }
/** * Generate kubernetes service ports for cluster. * * @param kubernetesClusterContext * @param clusterId * @param cartridge */ private void generateKubernetesServicePorts( String applicationId, String clusterId, KubernetesClusterContext kubernetesClusterContext, Cartridge cartridge) { synchronized (KubernetesIaas.class) { if (cartridge != null) { StringBuilder portMappingStrBuilder = new StringBuilder(); for (PortMapping portMapping : Arrays.asList(cartridge.getPortMappings())) { Collection<ClusterPortMapping> clusterPortMappings = CloudControllerContext.getInstance().getClusterPortMappings(applicationId, clusterId); if (clusterPortMappings == null) { throw new CloudControllerException( String.format( "Cluster port mappings not found: " + "[application-id] %s [cluster-id] %s", applicationId, clusterId)); } ClusterPortMapping clusterPortMapping = findClusterPortMapping(clusterPortMappings, portMapping); if (clusterPortMappings == null) { throw new CloudControllerException( String.format( "Cluster port mapping not found: " + "[application-id] %s [cluster-id] %s [transport] %s", applicationId, clusterId, portMapping.getName())); } if (clusterPortMapping.getKubernetesServiceType() == null) { throw new CloudControllerException( String.format( "Kubernetes service type not " + "found [application-id] %s [cluster-id] %s [cartridge] %s", applicationId, clusterId, cartridge)); } String serviceType = portMapping.getKubernetesPortType(); clusterPortMapping.setKubernetesServiceType(serviceType); // If kubernetes service port is already set, skip setting a new one if (clusterPortMapping.getKubernetesServicePort() == 0) { if (serviceType.equals(KubernetesConstants.NODE_PORT)) { int nextServicePort = kubernetesClusterContext.getNextServicePort(); if (nextServicePort == -1) { throw new RuntimeException( String.format( "Could not generate service port: [cluster-id] %s " + "[port] %d", clusterId, portMapping.getPort())); } clusterPortMapping.setKubernetesServicePort(nextServicePort); } else { clusterPortMapping.setKubernetesServicePort(portMapping.getPort()); } } else { if (log.isDebugEnabled()) { log.debug( String.format( "Kubernetes service port is already set: [application-id] %s " + "[cluster-id] %s [port] %d [service-port] %d", applicationId, clusterId, clusterPortMapping.getPort(), clusterPortMapping.getKubernetesServicePort())); } } // Add port mappings to payload if (portMappingStrBuilder.toString().length() > 0) { portMappingStrBuilder.append(";"); } portMappingStrBuilder.append( String.format( "NAME:%s|PROTOCOL:%s|PORT:%d|PROXY_PORT:%d", clusterPortMapping.getName(), clusterPortMapping.getProtocol(), clusterPortMapping.getKubernetesServicePort(), clusterPortMapping.getProxyPort())); if (log.isInfoEnabled()) { log.info( String.format( "Kubernetes service port generated: [application-id] %s " + "[cluster-id] %s [port] %d [service-port] %d", applicationId, clusterId, clusterPortMapping.getPort(), clusterPortMapping.getKubernetesServicePort())); } } NameValuePair nameValuePair = new NameValuePair(PORT_MAPPINGS, portMappingStrBuilder.toString()); payload.add(nameValuePair); // Persist service ports added to cluster port mappings CloudControllerContext.getInstance().persist(); } } }
/** * Creates and returns proxy services for the cluster. * * @param kubernetesApi * @param clusterContext * @param kubernetesCluster * @param kubernetesClusterContext * @throws KubernetesClientException */ private void createKubernetesServices( KubernetesApiClient kubernetesApi, ClusterContext clusterContext, KubernetesCluster kubernetesCluster, KubernetesClusterContext kubernetesClusterContext) throws KubernetesClientException { String clusterId = clusterContext.getClusterId(); String cartridgeType = clusterContext.getCartridgeUuid(); Cartridge cartridge = CloudControllerContext.getInstance().getCartridge(cartridgeType); if (cartridge == null) { String message = "Could not create kubernetes services, cartridge not found: [cartridge] " + cartridgeType; log.error(message); throw new RuntimeException(message); } String sessionAffinity = null; Property sessionAffinityProperty = cartridge.getProperties().getProperty(KUBERNETES_SERVICE_SESSION_AFFINITY); if (sessionAffinityProperty != null) { sessionAffinity = sessionAffinityProperty.getValue(); } List<KubernetesService> kubernetesServices = clusterContext.getKubernetesServices(); if (kubernetesServices == null) { kubernetesServices = new ArrayList<KubernetesService>(); } // Prepare minion public IP addresses List<String> minionPrivateIPList = new ArrayList<String>(); List<String> minionPublicIPList = new ArrayList<String>(); KubernetesHost[] kubernetesHosts = kubernetesCluster.getKubernetesHosts(); if ((kubernetesHosts == null) || (kubernetesHosts.length == 0) || (kubernetesHosts[0] == null)) { throw new RuntimeException( "Hosts not found in kubernetes cluster: [cluster] " + kubernetesCluster.getClusterUuid()); } for (KubernetesHost host : kubernetesHosts) { if (host != null) { minionPrivateIPList.add(host.getPrivateIPAddress()); minionPublicIPList.add(host.getPublicIPAddress()); } } if (log.isDebugEnabled()) { log.debug(String.format("Minion private IPs: %s", minionPrivateIPList)); } Collection<ClusterPortMapping> clusterPortMappings = CloudControllerContext.getInstance() .getClusterPortMappings(clusterContext.getApplicationUuid(), clusterId); if (clusterPortMappings != null) { for (ClusterPortMapping clusterPortMapping : clusterPortMappings) { // Skip if already created int containerPort = clusterPortMapping.getPort(); if (kubernetesServiceExist(kubernetesServices, containerPort)) { continue; } // Find next service sequence no long serviceSeqNo = kubernetesClusterContext.getServiceSeqNo().incrementAndGet(); String serviceId = KubernetesIaasUtil.fixSpecialCharacters("service" + "-" + (serviceSeqNo)); String serviceLabel = DigestUtils.md5Hex(clusterId); if (log.isInfoEnabled()) { log.info( String.format( "Creating kubernetes service: [cluster] %s [service] %s [service-label] %s " + "[protocol] %s [service-port] %d [container-port] %s", clusterId, serviceId, serviceLabel, clusterPortMapping.getProtocol(), clusterPortMapping.getKubernetesServicePort(), containerPort)); } // Create kubernetes service for port mapping int servicePort = clusterPortMapping.getKubernetesServicePort(); String serviceType = clusterPortMapping.getKubernetesServiceType(); String containerPortName = KubernetesIaasUtil.preparePortNameFromPortMapping(clusterPortMapping); try { // If kubernetes service is already created, skip creating a new one if (kubernetesApi.getService(serviceId) == null) { // Services need to use minions private IP addresses for creating iptable rules kubernetesApi.createService( serviceId, serviceLabel, servicePort, serviceType, containerPortName, containerPort, sessionAffinity); } else { if (log.isDebugEnabled()) { log.debug( String.format( "Kubernetes service is already created: [cluster] %s [service] %s " + "[protocol] %s [service-port] %d [container-port] %d", clusterId, serviceId, clusterPortMapping.getProtocol(), servicePort, containerPort)); } } } finally { // Persist kubernetes service sequence no CloudControllerContext.getInstance().persist(); } try { Thread.sleep(1000); } catch (InterruptedException ignore) { } Service service = kubernetesApi.getService(serviceId); KubernetesService kubernetesService = new KubernetesService(); kubernetesService.setId(service.getMetadata().getName()); kubernetesService.setPortalIP(service.getSpec().getClusterIP()); // Expose minions public IP addresses as they need to be accessed by external networks String[] minionPublicIPArray = minionPublicIPList.toArray(new String[minionPublicIPList.size()]); kubernetesService.setPublicIPs(minionPublicIPArray); kubernetesService.setProtocol(clusterPortMapping.getProtocol()); kubernetesService.setPortName(clusterPortMapping.getName()); String kubernetesServiceType = service.getSpec().getType(); kubernetesService.setServiceType(kubernetesServiceType); if (kubernetesServiceType.equals(KubernetesConstants.NODE_PORT)) { kubernetesService.setPort(service.getSpec().getPorts().get(0).getNodePort()); } else { kubernetesService.setPort(service.getSpec().getPorts().get(0).getPort()); } kubernetesService.setContainerPort(containerPort); kubernetesServices.add(kubernetesService); if (log.isInfoEnabled()) { log.info( String.format( "Kubernetes service successfully created: [cluster] %s [service] %s " + "[protocol] %s [node-port] %d [container-port] %s", clusterId, serviceId, clusterPortMapping.getProtocol(), servicePort, containerPort)); } } } // Add kubernetes services to cluster context and persist clusterContext.setKubernetesServices(kubernetesServices); CloudControllerContext.getInstance().persist(); }
/** * Create new pod and pass environment variables. * * @param memberContext * @param kubernetesApi * @param kubernetesClusterContext * @throws KubernetesClientException */ private void createPod( ClusterContext clusterContext, MemberContext memberContext, KubernetesApiClient kubernetesApi, KubernetesClusterContext kubernetesClusterContext) throws KubernetesClientException { String applicationId = memberContext.getApplicationId(); String cartridgeType = memberContext.getCartridgeType(); String clusterId = memberContext.getClusterId(); String memberId = memberContext.getMemberId(); if (log.isInfoEnabled()) { log.info( String.format( "Creating kubernetes pod: [application] %s [cartridge] %s [member] %s", applicationId, cartridgeType, memberId)); } Partition partition = memberContext.getPartition(); if (partition == null) { String message = String.format( "Partition not found in member context: [application] %s [cartridge] %s " + "[member] %s ", applicationId, cartridgeType, memberId); log.error(message); throw new RuntimeException(message); } Cartridge cartridge = CloudControllerContext.getInstance().getCartridge(cartridgeType); if (cartridge == null) { String message = "Could not find cartridge: [cartridge] " + cartridgeType; log.error(message); throw new RuntimeException(message); } // Set default values to zero to avoid cpu and memory restrictions int cpu = Integer.getInteger(KUBERNETES_CONTAINER_CPU_DEFAULT, 0); int memory = Integer.getInteger(KUBERNETES_CONTAINER_MEMORY_DEFAULT, 0); Property cpuProperty = cartridge.getProperties().getProperty(KUBERNETES_CONTAINER_CPU); if (cpuProperty != null) { cpu = Integer.parseInt(cpuProperty.getValue()); } Property memoryProperty = cartridge.getProperties().getProperty(KUBERNETES_CONTAINER_MEMORY); if (memoryProperty != null) { memory = Integer.parseInt(memoryProperty.getValue()); } IaasProvider iaasProvider = CloudControllerContext.getInstance() .getIaasProviderOfPartition(cartridge.getUuid(), partition.getUuid()); if (iaasProvider == null) { String message = "Could not find iaas provider: [partition] " + partition.getUuid(); log.error(message); throw new RuntimeException(message); } // Add dynamic payload to the member context memberContext.setDynamicPayload(payload.toArray(new NameValuePair[payload.size()])); // Create pod long podSeqNo = kubernetesClusterContext.getPodSeqNo().incrementAndGet(); String podId = "pod" + "-" + podSeqNo; String podLabel = DigestUtils.md5Hex(clusterId); String dockerImage = iaasProvider.getImage(); List<EnvVar> environmentVariables = KubernetesIaasUtil.prepareEnvironmentVariables(clusterContext, memberContext); List<ContainerPort> ports = KubernetesIaasUtil.convertPortMappings(Arrays.asList(cartridge.getPortMappings())); log.info( String.format( "Starting pod: [application] %s [cartridge] %s [member] %s " + "[cpu] %d [memory] %d MB", memberContext.getApplicationId(), memberContext.getCartridgeType(), memberContext.getMemberId(), cpu, memory)); kubernetesApi.createPod(podId, podLabel, dockerImage, cpu, memory, ports, environmentVariables); log.info( String.format( "Pod started successfully: [application] %s [cartridge] %s [member] %s " + "[pod] %s [cpu] %d [memory] %d MB", memberContext.getApplicationId(), memberContext.getCartridgeType(), memberContext.getMemberId(), podId, cpu, memory)); // Add pod id to member context memberContext.setKubernetesPodId(podId); memberContext.setKubernetesPodLabel(podLabel); // Create instance metadata InstanceMetadata instanceMetadata = new InstanceMetadata(); instanceMetadata.setImageId(dockerImage); instanceMetadata.setCpu(cpu); instanceMetadata.setRam(memory); memberContext.setInstanceMetadata(instanceMetadata); // Persist cloud controller context CloudControllerContext.getInstance().persist(); }
public static void handleServiceCreated(List<Cartridge> cartridgeList) { Service service; Topology topology = TopologyManager.getTopology(); if (cartridgeList == null) { log.warn(String.format("Cartridge list is empty")); return; } try { TopologyManager.acquireWriteLock(); for (Cartridge cartridge : cartridgeList) { if (!topology.serviceExists(cartridge.getType())) { ServiceType serviceType = cartridge.isMultiTenant() ? ServiceType.MultiTenant : ServiceType.SingleTenant; service = new Service(cartridge.getType(), serviceType); Properties properties = new Properties(); try { Property[] propertyArray = null; if (cartridge.getProperties() != null) { if (cartridge.getProperties().getProperties() != null) { propertyArray = cartridge.getProperties().getProperties(); } } List<Property> propertyList = new ArrayList<Property>(); if (propertyArray != null) { propertyList = Arrays.asList(propertyArray); if (propertyList != null) { for (Property property : propertyList) { properties.setProperty(property.getName(), property.getValue()); } } } } catch (Exception e) { log.error(e); } service.setProperties(properties); if (cartridge.getPortMappings() != null) { List<PortMapping> portMappings = Arrays.asList(cartridge.getPortMappings()); Port port; // adding ports to the event for (PortMapping portMapping : portMappings) { port = new Port( portMapping.getProtocol(), portMapping.getPort(), portMapping.getProxyPort()); service.addPort(port); } } topology.addService(service); TopologyManager.updateTopology(topology); } } } finally { TopologyManager.releaseWriteLock(); } TopologyEventPublisher.sendServiceCreateEvent(cartridgeList); }
public static void handleMemberActivated(InstanceActivatedEvent instanceActivatedEvent) { Topology topology = TopologyManager.getTopology(); Service service = topology.getService(instanceActivatedEvent.getServiceName()); if (service == null) { log.warn(String.format("Service %s does not exist", instanceActivatedEvent.getServiceName())); return; } Cluster cluster = service.getCluster(instanceActivatedEvent.getClusterId()); if (cluster == null) { log.warn(String.format("Cluster %s does not exist", instanceActivatedEvent.getClusterId())); return; } Member member = cluster.getMember(instanceActivatedEvent.getMemberId()); if (member == null) { log.warn(String.format("Member %s does not exist", instanceActivatedEvent.getMemberId())); return; } MemberActivatedEvent memberActivatedEvent = new MemberActivatedEvent( instanceActivatedEvent.getServiceName(), instanceActivatedEvent.getClusterId(), instanceActivatedEvent.getClusterInstanceId(), instanceActivatedEvent.getMemberId(), instanceActivatedEvent.getNetworkPartitionId(), instanceActivatedEvent.getPartitionId()); // grouping - set grouid // TODO memberActivatedEvent.setApplicationId(null); try { TopologyManager.acquireWriteLock(); // try update lifecycle state if (!member.isStateTransitionValid(MemberStatus.Active)) { log.error( "Invalid state transition from [" + member.getStatus() + "] to [" + MemberStatus.Active + "]"); return; } else { member.setStatus(MemberStatus.Active); // Set member ports try { Cartridge cartridge = CloudControllerContext.getInstance().getCartridge(service.getServiceName()); if (cartridge == null) { throw new RuntimeException( String.format( "Cartridge not found: [cartridge-type] %s", service.getServiceName())); } Port port; int portValue; List<PortMapping> portMappings = Arrays.asList(cartridge.getPortMappings()); String clusterId = cluster.getClusterId(); ClusterContext clusterContext = CloudControllerContext.getInstance().getClusterContext(clusterId); List<KubernetesService> kubernetesServices = clusterContext.getKubernetesServices(); for (PortMapping portMapping : portMappings) { if (kubernetesServices != null) { portValue = findKubernetesServicePort(clusterId, kubernetesServices, portMapping); } else { portValue = portMapping.getPort(); } port = new Port(portMapping.getProtocol(), portValue, portMapping.getProxyPort()); member.addPort(port); memberActivatedEvent.addPort(port); } } catch (Exception e) { String message = String.format( "Could not add member ports: [service-name] %s [member-id] %s", memberActivatedEvent.getServiceName(), memberActivatedEvent.getMemberId()); log.error(message, e); } // Set member ip addresses memberActivatedEvent.setDefaultPrivateIP(member.getDefaultPrivateIP()); memberActivatedEvent.setMemberPrivateIPs(member.getMemberPrivateIPs()); memberActivatedEvent.setDefaultPublicIP(member.getDefaultPublicIP()); memberActivatedEvent.setMemberPublicIPs(member.getMemberPublicIPs()); TopologyManager.updateTopology(topology); // Publish member activated event TopologyEventPublisher.sendMemberActivatedEvent(memberActivatedEvent); // Publish statistics data BAMUsageDataPublisher.publish( memberActivatedEvent.getMemberId(), memberActivatedEvent.getPartitionId(), memberActivatedEvent.getNetworkPartitionId(), memberActivatedEvent.getClusterId(), memberActivatedEvent.getServiceName(), MemberStatus.Active.toString(), null); } } finally { TopologyManager.releaseWriteLock(); } }
public static CartridgeInfo toCartridgeInfo(Cartridge cartridge) { CartridgeInfo carInfo = new CartridgeInfo(); carInfo.setType(cartridge.getType()); carInfo.setDisplayName(cartridge.getDisplayName()); carInfo.setDescription(cartridge.getDescription()); carInfo.setHostName(cartridge.getHostName()); carInfo.setDeploymentDirs(cartridge.getDeploymentDirs()); carInfo.setProvider(cartridge.getProvider()); carInfo.setVersion(cartridge.getVersion()); carInfo.setMultiTenant(cartridge.isMultiTenant()); carInfo.setBaseDir(cartridge.getBaseDir()); carInfo.setLbConfig(cartridge.getLbConfig()); carInfo.setDefaultAutoscalingPolicy(cartridge.getDefaultAutoscalingPolicy()); carInfo.setDefaultDeploymentPolicy(cartridge.getDefaultDeploymentPolicy()); carInfo.setPortMappings( cartridge.getPortMappings().toArray(new PortMapping[cartridge.getPortMappings().size()])); carInfo.setAppTypes( cartridge.getAppTypeMappings().toArray(new AppType[cartridge.getAppTypeMappings().size()])); List<Property> propList = new ArrayList<Property>(); carInfo.setPersistence(cartridge.getPersistence()); for (Iterator<?> iterator = cartridge.getProperties().entrySet().iterator(); iterator.hasNext(); ) { @SuppressWarnings("unchecked") Map.Entry<String, String> entry = (Entry<String, String>) iterator.next(); Property prop = new Property(entry.getKey(), entry.getValue()); propList.add(prop); } Property[] props = new Property[propList.size()]; carInfo.setProperties(propList.toArray(props)); return carInfo; }
@SuppressWarnings("unchecked") public static Cartridge toCartridge(CartridgeConfig config) { if (config == null) { return null; } Cartridge cartridge = new Cartridge(); // populate cartridge cartridge.setType(config.getType()); cartridge.setDisplayName(config.getDisplayName()); cartridge.setDescription(config.getDescription()); cartridge.setHostName(config.getHostName()); String[] deploymentDirs = config.getDeploymentDirs(); if ((deploymentDirs != null) && (deploymentDirs.length > 0)) { cartridge.setDeploymentDirs(Arrays.asList(deploymentDirs)); } cartridge.setProvider(config.getProvider()); cartridge.setVersion(config.getVersion()); cartridge.setBaseDir(config.getBaseDir()); if (config.getPortMappings() != null) { cartridge.setPortMappings(Arrays.asList(config.getPortMappings())); } if (config.getPersistence() != null) { cartridge.setPersistence(config.getPersistence()); } cartridge.setMultiTenant(config.isMultiTenant()); cartridge.setDefaultAutoscalingPolicy(config.getDefaultAutoscalingPolicy()); cartridge.setDefaultDeploymentPolicy(config.getDefaultDeploymentPolicy()); cartridge.setServiceGroup(config.getServiceGroup()); org.apache.stratos.cloud.controller.pojo.Properties props = config.getProperties(); if (props != null) { for (Property prop : props.getProperties()) { cartridge.addProperty(prop.getName(), prop.getValue()); } } // populate LB config cartridge.setLbConfig(config.getLbConfig()); List<IaasProvider> iaases = FasterLookUpDataHolder.getInstance().getIaasProviders(); // populate IaaSes IaasConfig[] iaasConfigs = config.getIaasConfigs(); if (iaasConfigs != null) { for (IaasConfig iaasConfig : iaasConfigs) { if (iaasConfig != null) { IaasProvider iaasProvider = null; if (iaases != null) { // check whether this is a reference to a predefined IaaS. for (IaasProvider iaas : iaases) { if (iaas.getType().equals(iaasConfig.getType())) { iaasProvider = new IaasProvider(iaas); break; } } } if (iaasProvider == null) { iaasProvider = new IaasProvider(); iaasProvider.setType(iaasConfig.getType()); } String className = iaasConfig.getClassName(); if (className != null) { iaasProvider.setClassName(className); } String name = iaasConfig.getName(); if (name != null) { iaasProvider.setName(name); } String identity = iaasConfig.getIdentity(); if (identity != null) { iaasProvider.setIdentity(identity); } String credential = iaasConfig.getCredential(); if (credential != null) { iaasProvider.setCredential(credential); } String provider = iaasConfig.getProvider(); if (provider != null) { iaasProvider.setProvider(provider); } String imageId = iaasConfig.getImageId(); if (imageId != null) { iaasProvider.setImage(imageId); } byte[] payload = iaasConfig.getPayload(); if (payload != null) { iaasProvider.setPayload(payload); } org.apache.stratos.cloud.controller.pojo.Properties props1 = iaasConfig.getProperties(); if (props1 != null) { for (Property prop : props1.getProperties()) { iaasProvider.addProperty(prop.getName(), prop.getValue()); } } NetworkInterfaces networkInterfaces = iaasConfig.getNetworkInterfaces(); if (networkInterfaces != null && networkInterfaces.getNetworkInterfaces() != null) { iaasProvider.setNetworkInterfaces(networkInterfaces.getNetworkInterfaces()); } cartridge.addIaasProvider(iaasProvider); } } } return cartridge; }