Set WshShell = WScript.CreateObject("WScript.Shell")
wshShell.run "rdiff-backup.exe d:\source D:\backup", 0, True
wshShell.run "rdiff-bakcup.exe --remove-older-than 6M D:\backup", 0, True
Set WshShell = nothing

import os
import subprocess

def ExecuteCmd(self, strCmd):
    print "[ExecuteCmd] %s" % (strCmd)
    pipe = subprocess.Popen(strCmd,
        shell=True,
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE)

    pipe.stdin.close()

    retOutputList = []

    while( pipe.poll() is None ):
        out = pipe.stdout.readline()
        if( out != '' ):
            print out
            retOutputList.append(out)

    retCode = pipe.poll()
    return (retCode, retOutputList)
	
def main():
	(retCode, stdout) = ExecuteCmd('svn --version')
	print 'retCode : ' + str(retCode)
	print stdout
		
if __name__ == "__main__":
	try:
		main()
	except os.error, err:
		print str(err)

USE [DBName]
GO

DECLARE @SysObjectCount INT
SELECT @SysObjectCount = COUNT('') FROM SYSOBJECTS WITH(NOLOCK)
    
-- Drop Views
BEGIN
     DECLARE @IndexForView INT
     SET @IndexForView = 0

     WHILE ( @IndexForView < @SysObjectCount )
     BEGIN
        DECLARE @VIEW_NAME VARCHAR(MAX)
        DECLARE VIEW_LIST CURSOR FOR
            SELECT NAME FROM SYSOBJECTS O2 WHERE XTYPE='V'
        OPEN VIEW_LIST
        FETCH NEXT FROM VIEW_LIST INTO @VIEW_NAME 
        WHILE @@FETCH_STATUS = 0
        BEGIN
            PRINT 'DROPPING VIEW '+@VIEW_NAME
            EXEC ('DROP VIEW '+@VIEW_NAME) 
            FETCH NEXT FROM VIEW_LIST INTO @VIEW_NAME
        END 
        CLOSE VIEW_LIST
        DEALLOCATE VIEW_LIST
        SET @IndexForView = @IndexForView + 1
     END
END

-- Drop Procedures
BEGIN
     DECLARE @IndexForProcedure INT
     SET @IndexForProcedure = 0
    
     WHILE ( @IndexForProcedure < @SysObjectCount )
     BEGIN
        DECLARE @PROCEDURE_NAME VARCHAR(MAX)
        DECLARE PROCEDURE_LIST CURSOR FOR
            SELECT NAME FROM SYSOBJECTS O2 WHERE XTYPE='P'
        OPEN PROCEDURE_LIST
        FETCH NEXT FROM PROCEDURE_LIST INTO @PROCEDURE_NAME 
        WHILE @@FETCH_STATUS = 0
        BEGIN
            PRINT 'DROPPING PROCEDURE '+@PROCEDURE_NAME
            EXEC ('DROP PROCEDURE '+@PROCEDURE_NAME) 
            FETCH NEXT FROM PROCEDURE_LIST INTO @PROCEDURE_NAME
        END 
        CLOSE PROCEDURE_LIST
        DEALLOCATE PROCEDURE_LIST
        SET @IndexForProcedure = @IndexForProcedure + 1
     END
END

-- Drop Tables
BEGIN
     DECLARE @IndexForTable INT
     SET @IndexForTable = 0
     WHILE ( @IndexForTable < @SysObjectCount )
     BEGIN
        DECLARE @TABLE_NAME VARCHAR(MAX)
        DECLARE TABLE_LIST CURSOR FOR
            SELECT NAME FROM SYSOBJECTS O2 WHERE XTYPE='U' AND
               NOT EXISTS (
                    SELECT * FROM SYSFOREIGNKEYS K
                       JOIN SYSCOLUMNS C1 ON (K.FKEYID = C1.ID AND C1.COLID=K.FKEY)
                       JOIN SYSCOLUMNS C2 ON (K.RKEYID = C2.ID AND C2.COLID=K.RKEY)
                    WHERE C2.ID = O2.ID AND C1.ID <> O2.ID
               )
        OPEN TABLE_LIST
        FETCH NEXT FROM TABLE_LIST INTO @TABLE_NAME 
        WHILE @@FETCH_STATUS = 0
        BEGIN
            PRINT 'DROPPING TABLE '+@TABLE_NAME
            EXEC ('DROP TABLE '+@TABLE_NAME) 
            FETCH NEXT FROM TABLE_LIST INTO @TABLE_NAME
        END 
        CLOSE TABLE_LIST
        DEALLOCATE TABLE_LIST
        SET @IndexForTable = @IndexForTable + 1
     END
END

#cpu used percent
Target[CPU]: .1.3.6.1.4.1.9600.1.1.5.1.5.6.95.84.111.116.97.108&.1.3.6.1.4.1.9600.1.1.5.1.5.6.95.84.111.116.97.108:public@192.168.0.3
Title[CPU]: CPU used
PageTop[CPU]: 
CPU used %
MaxBytes[CPU]: 100
ShortLegend[CPU]: %
YSize[CPU]: 100
YLegend[CPU]: CPU used
Legend1[CPU]: CPU used
Legend2[CPU]:
Legend3[CPU]:
Legend4[CPU]:
LegendI[CPU]: CPU used
LegendO[CPU]:
Options[CPU]: growright,gauge
Unscaled[CPU]: ymwd

#memory available bytes
Target[Memory]: (.1.3.6.1.4.1.9600.1.1.2.2.0&.1.3.6.1.4.1.9600.1.1.2.19.0:public@192.168.0.3 * 1024 )
Title[Memory]: Memory Available Bytes
PageTop[Memory]: 
Memory Available Bytes
MaxBytes[Memory]: 8589934592
ShortLegend[Memory]: B
kilo[Memory]: 1024
YSize[Memory]: 100
YLegend[Memory]: memory
Legend1[Memory]: memory Available
Legend2[Memory]: memory Used
Legend3[Memory]:
Legend4[Memory]:
LegendI[Memory]: Available Memory
LegendO[Memory]: Used Memory
Options[Memory]: growright,gauge,nopercent
Unscaled[Memory]: ymwd


# HDD.C Avalable Percent 
Target[HDD.C]: .1.3.6.1.4.1.9600.1.1.1.1.5.2.67.58&.1.3.6.1.4.1.9600.1.1.1.1.5.2.67.58:public@192.168.0.3
Title[HDD.C]: DISK Avalable Percent
PageTop[HDD.C]: 
HDD.C Avalable Percent
MaxBytes[HDD.C]: 100
ShortLegend[HDD.C]: %
YLegend[HDD.C]: Disk Avalable Percent
Legend1[HDD.C]: Current DISK Available percentage 
LegendI[HDD.C]: Available(Not used)
LegendO[HDD.C]:
Options[HDD.C]: growright,nopercent,gauge
Unscaled[HDD.C]: ymwd

# HDD.D Avalable Percent 
Target[HDD.D]: .1.3.6.1.4.1.9600.1.1.1.1.5.2.68.58&.1.3.6.1.4.1.9600.1.1.1.1.5.2.68.58:public@192.168.0.3
Title[HDD.D]: DISK Avalable Percent
PageTop[HDD.D]: 
HDD.D Avalable Percent
MaxBytes[HDD.D]: 100
ShortLegend[HDD.D]: %
YLegend[HDD.D]: Disk Avalable Percent
Legend1[HDD.D]: Current DISK Available percentage 
LegendI[HDD.D]: Available(Not used)
LegendO[HDD.D]:
Options[HDD.D]: growright,nopercent,gauge
Unscaled[HDD.D]: ymwd

# HDD.E Avalable Percent
Target[HDD.E]: .1.3.6.1.4.1.9600.1.1.1.1.5.2.69.58&.1.3.6.1.4.1.9600.1.1.1.1.5.2.69.58:public@192.168.0.3
Title[HDD.E]: DISK Avalable Percent
PageTop[HDD.E]: 
HDD.E Avalable Percent
MaxBytes[HDD.E]: 100
ShortLegend[HDD.E]: %
YLegend[HDD.E]: Disk Avalable Percent
Legend1[HDD.E]: Current DISK Available percentage 
LegendI[HDD.E]: Available(Not used)
LegendO[HDD.E]:
Options[HDD.E]: growright,nopercent,gauge
Unscaled[HDD.E]: ymwd

### Interface 11 >> Descr: 'Realtek-PCIe-GBE-Family-Controller' | Name: 'ethernet_5' | Ip: '192.168.0.3' | Eth: '' ###

Target[192.168.0.3_11]: 11:public@192.168.0.3:
SetEnv[192.168.0.3_11]: MRTG_INT_IP="192.168.0.3" MRTG_INT_DESCR="Realtek-PCIe-GBE-Family-Controller"
MaxBytes[192.168.0.3_11]: 12500000
Title[192.168.0.3_11]: Traffic Analysis for 11 -- Server2008R2
Options[192.168.0.3_11]: growright
PageTop[192.168.0.3_11]: 
Traffic Analysis for 11 -- Server2008R2
		

			

				

					
System:
					
Server2008R2 in SERVER2008R2
				
				

					
Maintainer:
					
00-000-0000
				
				

					
Description:
					
Realtek-PCIe-GBE-Family-Controller  
				
				

					
ifType:
					
ethernetCsmacd (6)
				
				

					
ifName:
					
ethernet_5
				
				

					
Max Speed:
					
12.5 MBytes/s
				
				

					
Ip:
					
192.168.0.3 (Server2008R2)
				
			
		

DBCC CHECKIDENT( [Table Name], RESEED, 0 )

SET IDENTITY_INSERT test ON

INSERT [Table Name] (ID, Context) values( 0, 'Context' )

SET IDENTITY_INSERT test OFF

MMORPG에서_좁은_지역에_유저_N명이_모여_있을때_처리_방법.pdf

1. 기획적 의도로 해결하는 방법

• 국지전이 일어나는 장소를 여러 곳으로 분할한다.
• 국지전에 참여할 수 있는 최대 인원수를 제한한다.

2. 프로그램적으로 해결하는 방법

• 영향을 미치는 요소들
• 데이터 크기
• 데이터를 보내는 빈도 수
• 전송 특성
• 1:1 패킷 보내기
• 1:N 패킷 보내기
• N:M 패킷 보내기
  
• 해결방법
• 데이터 크기
• 패킷 데이터의 크기를 최대한 줄인다.
• 패킷에 포함된 기본 정보 단위를 최소화 한다.
  ( 자료형 단위를 줄이는 방법, 불필요한 정보를 제거하는 방법 )
• 패킷 데이터를 압축한다.
• 패킷 데이터를 압축/해제시 CPU 자원을 사용한다.
• 브로드캐스팅할 경우 패킷이 작아지면 트래픽이 줄어드는 잇점이 있다.
              
• 데이터를 보내는 빈도 수
• 최대 빈도수를 정한다.
• 클라이언트 응답 속도 250ms일 경우 1초에 4번
• 클라이언트 응답 속도 200ms일 경우 1초에 5번
  (이동 패킷과 스킬 사용 패킷을 1초에 4-5번으로 해결하기 어렵다.)
• 우선순위 큐를 이용한 패킷 전송
• 전투 관련 패킷을 우선적으로 처리한다.
• 비우선 패킷들 : 로그, 채팅, 환경 오브젝트 처리
• 이미 전송한 명령은 Send 버퍼 Queue에서 삭제한다.
• 동일한 좌표로 계속 이동하는 패킷은 클라이언트에서 한번만 보내도 된다.
• 필요 없는 패킷을 제거하여, 트래픽도 줄이고 서버의 CPU 자원 사용도 줄일 수 있다.
     
• 전송 특성
• 1:1 패킷 보내기
• 문제점 없음
• 1:N 패킷 보내기
• Send 패킷 버퍼 재활용 필요함.
• N:M 패킷 보내기
• 패킷 압축 필요함.
• Send 패킷 버퍼 재활용 필요함.
• 브로드캐스팅을 게임 서버에서 하지 않고, Front 혹은 Agent 서버로 패스하여 처리한다.
  (UDP SuperPeer를 사용할 경우 클라이언트에서 브로드 캐스팅하는 것도 고려해 볼 수 있다.)

3. 그외에 더 생각해 볼 사항

• CPU 자원
• 메모리간 데이터 복사를 최소화 한다.
• C++0x의 std::move를 사용하여 데이터 값 복사를 줄인다.
• Reference Count 기능을 가진 패킷 컨테이너를 사용한다.
• 메모리간 데이터 복사를 빠르게 한다.
• FastMemcpy와 같이 CPU의 기본 레지스터 이외의 MMX와 같은 크기가 큰 레지스터에 데이터를 unrolling 하여,
  Loop를 이용한 데이터 복사 속도 저하를 개선한다.
       
• 네트워크 자원
• 보장이 필요한 패킷과 보장이 필요 없는 패킷으로 구분하여 처리한다.
• 보장이 필요한 패킷 : 주기적인 시간 간격으로 동기화에 필요한 중요한 정보
  예) X, Y, Z, 좌표 + Angle
• 보장이 필요 없는 패킷 : 주기적인 시간 간격보다 짧은 간격이면서, 손실되어도 문제 없는 정보
  예) Angle 정보
• 보장이 필요한 패킷은 TCP로 보내고, 보장이 필요 없는 패킷은 UDP로 나누어 처리할 수 있다.
  (단, 중국의 경우 UDP가 불가능한 상황도 발생한다.)
      
• 브로드 캐스팅을 주체하는 서버를 구분한다.
• Game 서버가 모든 패킷을 브로드캐스팅 하면, Front 혹은 Agent 서버에 N번의 요청을 전달한다.
• 브로드캐스팅이 필요한 패킷을 각 Front 혹은 Agent 서버에 1회만 보내고(받을 클라이언트 목록을 함께), Front 혹은 Agent 서버에서 처리한다면,
  Game 서버에서 N번 요청에 대한 CPU 자원 사용을 줄이고, 내부 네트워크 트래픽도 감소한다.
      
• 유저 상태에 대한 패킷 처리
• 유저가 전투 상태일 경우 패킷을 먼저 처리하고,
  비 전투 상태일 경우 나중에 처리하도록 한다.
  예) 마을에 모인 유저인 경우, 패킷이 늦게 처리되어도 문제가 발생하지 않는다.

POSA2 책의 Proactor 항목을 요약 정리 하였습니다.
POSA2 원문에 대한 의역 혹은 오역이 있을 수 있습니다.

Xmind 파일을 첨부합니다.
Xmind 프로그램이 없으신 분은 http://www.xmind.net/downloads 에서 다운로드 받으실 수 있습니다.

Proactor.xmind

#include "ShortestPath.h"

int _tmain(int argc, _TCHAR* argv[])
{
	setlocale( LC_ALL, "Korean" );

	CShortestPath ShortestPath;
	ShortestPath.BuildGraph();

	return 0;
}

BuildGraph()에서 하는 일은 다음과 같습니다.

• Vertex 추가 / 이름 설정
• Edge 추가 / 이름 / 가중치 설정
• boost::dijkstra_shortest_paths()로 최단 거리 구하기
• PrintShortestPath( vStartVertex )에서 시작 vertex를 지정하고 최단거리 Console로 출력하기
• WriteGraphviz()에서 Graphviz.dot 파일로 그래프 파일 출력하기

void CShortestPath::BuildGraph()
{
	//////////////////////////////////////////////////////////////////////////
	// Vertex 추가하기
	const VertexDescriptor vA  = boost::add_vertex( m_Graph );
	const VertexDescriptor vB  = boost::add_vertex( m_Graph );
	const VertexDescriptor vC  = boost::add_vertex( m_Graph );
	const VertexDescriptor vD  = boost::add_vertex( m_Graph );
	const VertexDescriptor vE  = boost::add_vertex( m_Graph );

	// Vertex 이름 설정하기
	boost::put( boost::vertex_name, m_Graph, vA, "A" );
	boost::put( boost::vertex_name, m_Graph, vB, "B" );
	boost::put( boost::vertex_name, m_Graph, vC, "C" );
	boost::put( boost::vertex_name, m_Graph, vD, "D" );
	boost::put( boost::vertex_name, m_Graph, vE, "E" );



	//////////////////////////////////////////////////////////////////////////
	// Edge 추가하기
	const EdgeDescriptor eAC = boost::add_edge( vA, vC, m_Graph ).first;
	const EdgeDescriptor eBB = boost::add_edge( vB, vB, m_Graph ).first;
	const EdgeDescriptor eBD = boost::add_edge( vB, vD, m_Graph ).first;
	const EdgeDescriptor eBE = boost::add_edge( vB, vE, m_Graph ).first;
	const EdgeDescriptor eCB = boost::add_edge( vC, vB, m_Graph ).first;
	const EdgeDescriptor eCD = boost::add_edge( vC, vD, m_Graph ).first;
	const EdgeDescriptor eDE = boost::add_edge( vD, vE, m_Graph ).first;
	const EdgeDescriptor eEB = boost::add_edge( vE, vB, m_Graph ).first;
	const EdgeDescriptor eEA = boost::add_edge( vE, vA, m_Graph ).first;

	// Edge 이름 설정하기
	boost::put( boost::edge_name, m_Graph, eAC, "AC" );
	boost::put( boost::edge_name, m_Graph, eBB, "BB" );
	boost::put( boost::edge_name, m_Graph, eBD, "BD" );
	boost::put( boost::edge_name, m_Graph, eBE, "BE" );
	boost::put( boost::edge_name, m_Graph, eCB, "CB" );
	boost::put( boost::edge_name, m_Graph, eCD, "CD" );
	boost::put( boost::edge_name, m_Graph, eDE, "DE" );
	boost::put( boost::edge_name, m_Graph, eEB, "EB" );
	boost::put( boost::edge_name, m_Graph, eEA, "EA" );
	
	// Edge에 가중치 설정하기
	boost::put( boost::edge_weight, m_Graph, eAC, 1 );
	boost::put( boost::edge_weight, m_Graph, eBB, 2 );
	boost::put( boost::edge_weight, m_Graph, eBD, 1 );
	boost::put( boost::edge_weight, m_Graph, eBE, 2 );
	boost::put( boost::edge_weight, m_Graph, eCB, 7 );
	boost::put( boost::edge_weight, m_Graph, eCD, 3 );
	boost::put( boost::edge_weight, m_Graph, eDE, 1 );
	boost::put( boost::edge_weight, m_Graph, eEB, 1 );
	boost::put( boost::edge_weight, m_Graph, eEA, 1 );


	//////////////////////////////////////////////////////////////////////////
	// Shortest Path 구하기

	// Property Map 가져오기
	boost::property_map< Graph, boost::edge_weight_t >::type		mapEdgeWeight			= boost::get( boost::edge_weight, m_Graph );
	boost::property_map< Graph, boost::vertex_index_t >::type		mapVertexIndex			= boost::get( boost::vertex_index, m_Graph );
	boost::property_map< Graph, boost::vertex_distance_t >::type	mapVertexDistance		= boost::get( boost::vertex_distance, m_Graph );
	boost::property_map< Graph, boost::vertex_predecessor_t >::type	mapVertexPredecessor	= boost::get( boost::vertex_predecessor, m_Graph );

	// 다익스트라 최단거리 알고리즘
	const VertexDescriptor vStartVertex = vA;
	boost::dijkstra_shortest_paths(
		m_Graph, 
		vStartVertex,
		boost::weight_map( mapEdgeWeight ).vertex_index_map( mapVertexIndex ).distance_map( mapVertexDistance ).predecessor_map( mapVertexPredecessor )
		); 


	//////////////////////////////////////////////////////////////////////////
	// 최단거리 결과 출력
	PrintShortestPath( vStartVertex );

	// Dot 파일로 출력
	WriteGraphviz();
}

기존 BGL 책에 소개된 배열 기반의 예제를 탈피해서,

STL을 주로 사용하시는 분들에 맞게 코드를 작성하였습니다.

BoostGraph_ShortestPath.zip

다른 기능을 추가하고자 하신다면, boost.org의 Graph 라이브러리 페이지를 참조하세요.