linuxism

RPM 패키지 매니저(RPM Package Manager←Red Hat Package Manager)는 원래 레드햇에서 사용되었던 패키지 파일이었지만 현재는 많은 RPM 기반 배포판이 사용되고 있다. 이는 두 가지를 말하는데, 하나는 RPM 패키지 그 자체와 또 하나는 RPM 패키지를 관리하기 위한 도구이다. RPM을 사용하면 각종 소프트웨어의 설치 및 업데이트를 굉장히 편리하게 할 수 있다.

RPM은 Linux Standard Base의 표준 패키지 포맷 중 하나이다.

원래 레드햇 리눅스를 위한 것이었지만 많은 리눅스 배포판 및 노벨 넷웨어 (6.5 SP3 이후), IBM AIX 5 등으로 이식되었다.

현재의 이름 "RPM"은 재귀 약자의 일종이다.

RPM ( R PM P ackage M anager)는 레드햇 사가 개발 한 소프트웨어 패키지를 관리하는 시스템 ( 패키지 관리 시스템 ) 및 명령. 이전에는 R ed Hat P ackageM anager의 약자였다. " . rpm "확장자를 가진 파일을 이용한다.

주로 Linux 의 배포판 중 레드햇 사가 제공하는 것뿐만 아니라 자신의 정의를 포함하면서 SUSE Linux , Vine Linux 등의 RPM 계 배포판 에서 사용된다.

RPM은 패키지를 cpio 형식으로 압축되어 있으며, 그 중에는 자신의 spec 파일 및 바이너리 또는 소스 코드 가 포함되어있다. 패키지 관리를위한 데이터베이스 는Berkeley DB 를 사용하고 설치 시 제거시 패키지 문의시에이 데이터베이스가 이용된다. 데이터베이스 관리를위한 명령 옵션을 rpm 명령에 포함되어있다.

spec 파일에는 패키지의 이름, 개요, 의존하는 패키지 바이너리 패키지의 설치 경로 설치 전에 실행할 스크립트 설치 후 실행하는 스크립트 등이 적혀있다. 설치시에는 포함 된 스크립트를 실행하여 서버의 정지 및 복귀 시스템 사용자 추가 등을 통해 시스템의 안전을 지킨다.

spec 파일은 선언 부와 실행 부로 나뉘어있​​다. 선언 부분은 패키지의 기술적 인 세부 사항을 쓰고, 실행 부분은 스크립트로의 역할을하고있다.

패키지 설치는 로컬 패키지, HTTP , FTP 를 통한 네트워크에서의 패키지에 대응하고있다. 그러나 의존성의 해결은하지 않고 의존성에 부족이 있었을 경우는, 사용자가 직접 패키지를 설치하거나 YUM , APT for RPM 같은 다른 도구를 사용하여 해결해야 말라. 직접 소스 코드에서 설치 한 경우 패키지 관리의 대상이되지 않고,이 경우에는 의존성의 해결에는 이용되지 않는다.

RPM은 일반적으로 바이너리 설치에 사용되지만, 소스 코드에서 패키지 작성도 지원하고있다. 패키지를 spec 파일에 따라 그 자리에서 만들고 설치하게된다.

RPM은 C 언어 로 작성된 C 언어, Java , Perl , Python , Ruby 등의 언어 바인딩 도 제공하거나 직접 만들되며, 이는 명령 이외로부터도 RPM 패키지를 처리 할 수있다.

관련 항목 [ 편집 ]

• Linux Standard Base
• APT

외부 링크 [ 편집 ]

• rpm.org (영어)
• rpm package manager (영어)

출처 - http://ko.wikipedia.org/wiki/RPM_%ED%8C%A8%ED%82%A4%EC%A7%80_%EB%A7%A4%EB%8B%88%EC%A0%80

* 디렉토리 설정 시 주의 사항

[/trunk/] 와 [/trunk]는 다르게 적용 된다.

[/trunk]로 설정할 때 trunk 하위로 접근할 수 있다.

svn의 repository의 디렉토리 별로 권한을 각각 다르게 설정하는  방법

1. anonymous는 접근을 할수 없고, 계정이 있어야만 접근이 가능하다.

svnserve.conf 

2. repository에 

	/ /trunk /release /common /admin

네개의 폴더가 있어서

를 설정해 주고 싶을때...

authz

[groups]
admin = admin1, admin2

dev = aaa, bbb, ccc

user = ddd, eee, fff, ggg

### 

[/]
* = r

@admin = rw

[/trunk]

* = 
@admin = rw

@dev = rw

[/release]

* = 
@admin = rw
@dev = rw

@user = r

ddd = rw

[/common]

* = rw

[/admin]

* =

@admin = rw

출처 - http://blog.naver.com/PostView.nhn?blogId=arycoat&logNo=90058892624

알만한(?) 분들은 다 알지만 SVN의 인증과정을 관리하는 방법중 하나인 SVN Server의 자체 기능이 있다.

그럼 SVN server의 권한 인증을 사용한 한 예를 살펴보자.

X:\저장소\conf\ (윈도우기준)의 svnserve.conf 파일이 그 인증과 관련된 중요 파일이다.
그 파일의 내용은 아래 more버튼을 누르면 알 수 있듯이 매우 긴데 주석 부분을 제거 하고 나면

more..

svnserve.conf

요로코롬 짧아진다. 그럼 각각의 의미를 알아 보자.

[general]
anon-access=none           #인증되지않은(즉 계정이 없는) 사용자에 대해 접근을 거부한다.
auth-access = write          #인증된 사용자에 대해 쓰기 권한을 준다.
password-db = passwd     # 인증된 사용자에 대한 계정 정보(아이디/패스) 정보가 기록된 파일명을 의미한다.(기본값 passwd) 
authz-db = authz              # 인증된 사용자에 대해 저장소에 대한 권한 설정이 기록된 파일명(기본값)
#realm = Kanji_Proj             #현재 파일에 해당되는 저장소의 영역에 대해 설정하는 것인데 여기서는 주석처리로 하고 넘어가자.(ㅌㅌ)

즉, 인증된 사용자에게 저장소의 접근권한을 일체 주지 않고, 인증된 사용자에게만 접근을 허용하는 그런 의미를 갖는 svnserve.conf파일이 되겠다. 

다음으로 passwd 파일을 살펴보자.

passwd 

= 를 기준으로 왼쪽이 아이디 오른족이 비밀번호가 된다. 
id: aaa, pw: a
id: bbb, pw: b 이런식이다.

마지막으로 authz

authz

authz 파일의 의미를 살펴보자

[groups]
# harry_and_sally = harry,sally   # 사용자를 그룹단위로 묶을 수 있다.
gABC = aaa, bbb, ccc               # 즉, 사용자 aaa, bbb, ccc를 묶어서 gABC라는 그룹으로 관리.

# [/foo/bar]
# harry = rw
# * =

# [repository:/baz/fuz]             #repository저장소의 /baz/fuz위치에 대한 권한
# @harry_and_sally = rw            #@<-의 의미는 그룹을 뜻한다. harry_and_sally 그룹에 읽기/쓰기권한을 준다.
# * = r                                     # * 는 모든 사용자를 의미한다. 모든 사용자에게 읽기 권한을 준다.           

[ABC:/]                                 #ABC:/저장소
* = r                                       #모든 사용자에게 읽기 권한을 준다.
@gABC  = rw                          #gABC그룹에게 읽기/쓰기 권한을 준다.

여기까지가 SVN server을 사용해 인증관리를 하고 있는 한 예이다.

주의 1. authz 파일에 보면 *(와일드카드)가 모든 사용자를 의미한다고 했는데, 만약 svnserve.conf 파일에 anon-access=none (인증된 사용자에 대한 권한접근을 거부) 설정이 안되 있으면 말 그대로 아이디가 있건 없고 모든 접속한 사용자에 대한 권한이 되 버린다. 하지만 anon-access=none 이 설정되 되어 있다면 아이디/비번을(계정) 을 갖고 있는 사용자들에 대한 권한 설정이 될 것이다.

출처 - http://ummae.tistory.com/197

svn을 사용하다 보면, 사용자, 또는 그룹으로 묶어서 접근통제를 할 필요가 있는데 이것에 대한 자료는 많으나 나에게 딱 맞는 설명은 찾기가 어렵습니다.

svn은 http로 설정이 되어 있다는 가정에서 설명을 합니다.
먼저 httpd.conf
LoadModule dav_module modules/mod_dav.so
LoadModule dav_svn_module modules/mod_dav_svn.so
#svn의 권한 설정을 사용하게 함
LoadModule authz_svn_module modules/mod_authz_svn.so
DAV svn
SVNPath D:reposproject
AuthzSVNAccessFile d:/repos/project/conf/authz
AuthType Basic
AuthName “project”
AuthUserFile D:/www/subversion1.5.5/httpd/conf/passwd
Require valid-user

사용자는 D:/www/subversion1.5.5/httpd/conf/passwd의 설정을 사용하고
접근통제는 아래의 파일에서 합니다.
d:/repos/project/conf/authz
[groups]
projectteam=parknj,honggd
adminteam=honggd

#관리자그룹만 사용가능함
#관리자는 root를 rw를 해주면 전체에 접근이 가능하고
[/]
@adminteam=rw

#사용자지정, projectteam 그룹의 사용자는 아래의 경로에 read, write 가능하게 설정합니다.
#svn경로는 http://myhost/svn/project/web-spa
[/web-spa/trunk]
@projectteam=rw

이상, 접근통제 간단 설정입니다. 아 그리고 http는 재시작 해야 합니다.끝.

출처 - http://www.eahn.kr/wordpress/?p=489

To take full advantage of the object mapping functionality inside the Spring Data/MongoDB support, you should annotate your mapped objects with the@org.springframework.data.mongodb.core.mapping.Document annotation. Although it is not necessary for the mapping framework to have this annotation (your POJOs will be mapped correctly, even without any annotations), it allows the classpath scanner to find and pre-process your domain objects to extract the necessary metadata. If you don't use this annotation, your application will take a slight performance hit the first time you store a domain object because the mapping framework needs to build up its internal metadata model so it knows about the properties of your domain object and how to persist them.

package com.mycompany.domain;

@Document
public class Person {

  @Id
  private ObjectId id;

  @Indexed
  private Integer ssn;

  private String firstName;

  @Indexed
  private String lastName;

}
      

	Important
	The @Id annotation tells the mapper which property you want to use for the MongoDB _id property and the @Indexed annotation tells the mapping framework to call ensureIndex on that property of your document, making searches faster.

@Document
@CompoundIndexes({
    @CompoundIndex(name = "age_idx", def = "{'lastName': 1, 'age': -1}")
})
public class Person<T extends Address> {

  @Id
  private String id;

  @Indexed(unique = true)
  private Integer ssn;

  @Field("fName")
  private String firstName;

  @Indexed
  private String lastName;

  private Integer age;

  @Transient
  private Integer accountTotal;

  @DBRef
  private List<Account> accounts;

  private T address;

  
  public Person(Integer ssn) {
    this.ssn = ssn;
  }
  
  @PersistenceConstructor
  public Person(Integer ssn, String firstName, String lastName, Integer age, T address) {
    this.ssn = ssn;
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
    this.address = address;
  }

  public String getId() {
    return id;
  }

 // no setter for Id.  (getter is only exposed for some unit testing)

  public Integer getSsn() {
    return ssn;
  }


// other getters/setters ommitted

7.3.2 Compound Indexes

Compound indexes are also supported. They are defined at the class level, rather than on indidvidual properties.

	Note
	Compound indexes are very important to improve the performance of queries that involve criteria on multiple fields

Here's an example that creates a compound index of lastName in ascending order and age in descending order:

Example 7.4. Example Compound Index Usage

package com.mycompany.domain;

@Document
@CompoundIndexes({
    @CompoundIndex(name = "age_idx", def = "{'lastName': 1, 'age': -1}")
})
public class Person {

  @Id
  private ObjectId id;
  private Integer age;
  private String firstName;
  private String lastName;

}
          

7.3.3 Using DBRefs

The mapping framework doesn't have to store child objects embedded within the document. You can also store them separately and use a DBRef to refer to that document. When the object is loaded from MongoDB, those references will be eagerly resolved and you will get back a mapped object that looks the same as if it had been stored embedded within your master document.

Here's an example of using a DBRef to refer to a specific document that exists independently of the object in which it is referenced (both classes are shown in-line for brevity's sake):

Example 7.5. 

@Document
public class Account {

  @Id
  private ObjectId id;
  private Float total;

}

@Document
public class Person {

  @Id
  private ObjectId id;
  @Indexed
  private Integer ssn;
  @DBRef
  private List<Account> accounts;

}
        

There's no need to use something like @OneToMany because the mapping framework sees that you're wanting a one-to-many relationship because there is a List of objects. When the object is stored in MongoDB, there will be a list of DBRefs rather than the Account objects themselves.

	Important
	The mapping framework does not handle cascading saves. If you change an Account object that is referenced by a Person object, you must save the Account object separately. Calling save on the Person object will not automatically save the Account objects in the property accounts.

7.3.5 Overriding Mapping with explicit Converters

When storing and querying your objects it is convenient to have a MongoConverter instance handle the mapping of all Java types to DBObjects. However, sometimes you may want the MongoConverter's do most of the work but allow you to selectivly handle the conversion for a particular type or to optimize performance.

To selectivly handle the conversion yourself, register one or more one or more org.springframework.core.convert.converter.Converter instances with the MongoConverter.

	Note
	Spring 3.0 introduced a core.convert package that provides a general type conversion system. This is described in detail in the Spring reference documentation section entitled Spring 3 Type Conversion.

The setConverters method on SimpleMongoConverter and MappingMongoConverter should be used for this purpose. The methodafterMappingMongoConverterCreation in AbstractMongoConfiguration can be overriden to configure a MappingMongoConverter. The examples here at the begining of this chapter show how to perform the configuration using Java and XML.

Below is an example of a Spring Converter implementation that converts from a DBObject to a Person POJO.

public class PersonReadConverter implements Converter<DBObject, Person> {

  public Person convert(DBObject source) {
    Person p = new Person((ObjectId) source.get("_id"), (String) source.get("name"));
    p.setAge((Integer) source.get("age"));
    return p;
  }

}

Here is an example that converts from a Person to a DBObject.

public class PersonWriteConverter implements Converter<Person, DBObject> {

  public DBObject convert(Person source) {
    DBObject dbo = new BasicDBObject();
    dbo.put("_id", source.getId());
    dbo.put("name", source.getFirstName());
    dbo.put("age", source.getAge());
    return dbo;
  }

}

출처 - http://static.springsource.org/spring-data/data-mongodb/docs/current/reference/html/mapping-chapter.html