NOTE:  If you don’t have an account for the Issue Tracker, e-mail your registration request to: issuetracker@nationalmodel.us

The Issue Tracker is a useful tool that allows a state or province’s TraCS/MACH team member to enter the issue that they have, and for the TEG Support team to track and respond to that issue.

Before entering a new issue, it is recommended that you use the search bar at the top of the Issue Tracker first to see if the issue you’re experiencing has already been entered by somebody else. That way, if the issue has been released, you know that a simple software upgrade will address it.  If you find your issue already in the Tracker and the issue is still active, you can add to it with the information that your state/province has collected, giving further specifications for a suggestion/request, or more information to help track down and resolve a bug.  The more information TEG Support has the quicker issues can be resolved.

Should you find that your issue already exists in the Tracker, but its status is “Closed” or “Released”, there are a few steps you can follow. First, check that you are running the version listed as the “Release Version” or later for the issue.  If this is the case, you can create a new issue using the steps listed lower down in this post.  Adding comments to Closed or Released issues tend to be overlooked, as issues in those statuses are not actively reviewed.

NOTE:  When entering comments to an issue, you can include a link back to other Closed or Released issues that you find to be related to your issue.  To do this, simply add a comment that includes “bugid#0000” where 0000 is the issue number you want to link back to. This will be picked up by the issue tracker and turned into a hyperlink back to that issue.  Linking to older issues could assist with tracking down and addressing your new issue, and it could give further context and information relevant to the new issue being reported.

If you find that your issue does not yet exist in the Tracker, click on the ”add new issue” link at the top-left corner of the Issue Tracker screen. This will bring up a prompt to enter the relevant data about your issue.

The following 5 simple suggestions for entering a new issue will ensure the quickest possible resolution:

1. Ensure that your issue description includes the component of TraCS you are working with followed by a short description of the behavior you’re seeing. For instance, if the Forms Builder is failing to save your changes, a good description would be something like: “Forms Builder: Fails to save changes to existing forms and reports”.
2. Use as many of the available boxes as you can when filling out your issue. In particular, please try to include your name, state/province, and TraCS Baseline version used. This information lets TEG Support know who to contact should we have any follow-up questions, as well as to help recognize patterns and diagnose a root cause.
3. Always include steps to recreate. The steps to reproduce your issue are the most important, as everybody uses TraCS differently, and may use different steps to accomplish the same tasks. As such, it is very important to be as specific as possible so that TEG Support can follow your steps exactly in our efforts to reproduce the issue. If we are unable to reproduce the behavior, it is much more difficult for us to address the issue. For any issue that is not a general question, the steps to recreate are the most crucial to getting your issue addressed quickly.
4. Whenever possible, include a debug log of the behavior described. Sometimes, behaviors occur unpredictably, which makes a debug log difficult to acquire. However, if an issue can be reproduced regularly, a debug log can offer significant insight into potential causes of the issue.  Ask TEG Support if you don’t know how to use debug mode in TraCS 10.
5. Always include any files that are relevant to the issue. If an issue can be consistently recreated using a particular form, then attach that form file to the issue. TEG Support is going to ask you for these files anyhow, so including them when you first enter your issue will save that step and let us start reviewing your issue that much sooner.

Using the above guidelines will ensure that everyone will get the most benefit out of the Issue Tracker. Information is our most powerful tool in this effort, and the more that you can provide when creating a new issue, the better able we are to quickly fix issues or answer questions so that you can use TraCS to its fullest capacity.

This post can be found on the National Model Knowledge Base here.

Gonnasphere

Gonnasphere is an application that allows you to organize your to-dos and follow others. This productivity tool lets you tell your friends about the things that you plan to do. Your friends and then converse with you on that topic and provide you with encouragement. You can also help them with their stuff.

Apart from that, Gonnasphere also allows you to see the most popular to-dos in the city. Most people love to get along with somebody to try something new; therefore, Gonnasphere allows its users the opportunity to find to-dos that many people love. That means there are more chances of your loving it too.

You can everyday see what your friends are going to do. That not only makes you connect with them on a daily basis, but also keeps your up-to-date about their activities. It is a tremendous way to connect with others.

The positivity that Gonnasphere can bring into the lives of its users is tremendous. You can share your daily to-dos with your friends so that it helps you to concentrate and keep trying to get better. It is a great motivation when people are involved, especially friends, who encourage you and want the best for you.

On your Gonnasphere dashboard, you will see what your friends are up-to today, where the kind of activities you love are going to be held and what your favourite people have achieved.

With Gonnasphere, you don’t need to ask the question, “What are you going to do today?” You will know what your favourite people will be doing without the need to individually ask the question. It is wonderful social platform for those who love to keep in contact with their friends. Now, Gonnasphere has made it incredibly easy and time saving.

Ragic

Ragic helps you in letting your software fit you. It offers you super flexible CRM system, HR system, sales system, support system and DB applications. It’s tag-line ‘Don’t change to fit your software, let your software fit you’, sounds tempting.

On Ragic, you can easily find and install an application. You can browse their library for an application that is closest to your need. If you cannot find an app that you need, you can always make modifications on the one that is closest to your need.

Unlike the table-based approach, Ragic users are not required to create tables, relations, views or write any SQL. They only need to create the form for their users to fill in like they would in a spreadsheet.

Most apps in the library are free. All you need to run them is a Ragic account. You get a 30-day free trial for all Ragic accounts.

You can customize it like a spreadsheet. You can change the design of your application just by editing an online spreadsheet. If you want to add a field to your form, you can enter its name and it is created.

After you have become familiar with Ragic, you can set properties and even scripts to create highly complicated business applications. You can keep your current data on spreadsheets or you can import them into Ragic using their online wizard. If you have Ragic in a database, you can export them into Excel files for import. If you are a developer, you can use Ragic API to integrate your other application data with Ragic.

The mission of Ragic is to build enterprise web applications quick and easy. You can start with the free account with limited storage and databases, and move on from there.

Snowy- Evening

Bringing your clients and community together isn’t exactly an easy task to take. That’s why Snowy- evening lets you do the job quite simply. It is beautifully designed with trouble- free GitHub jsFiddle integration. Snowy is so smart that it can handle the details of managing and finding issues. You can simply use the API to keep track of all your errors of your apps.

The interface of Snowy is simple, clean, and well laid- out. Not only that, it is also very nice to look at. Aside from the beautiful interface, the project navigation is also very easy to use that you can actually jump between projects with just a few clicks, no matter where in the app you are. And in your overview, a summary of every open project you’re involved with will be given, and every statistic is a link to a pre-made filter.

Adding a lot of issues will be a constant activity on Snowy so it is made with the simplest process possible. Only an issue summary is required – every other field is set to sensible defaults. A full description, set versions, milestones, priorities, and even upload multiple files can be added when you need it.

It is also a known fact that every user needs to see a different issue list so filtering your lists with a very easy form and saving it for future use should be in order. Snowy does that with incredible competence. You can just easily jump between filters using links on the sidebar or better yet, use the filters for the most common list views.

There are more great features Snowy has to offer like a smart fast issue finder. But in a nutshell, this service really offers what it says it would. Everything is worthy of your time with its powerful and easy issue tracker.

BlackBerry® developers, you can now quickly locate and vote on issues logged by your peers. We have modified the configuration of Issue Tracker so that newly logged issues are by default visible to all other Issue Tracker users. You’ll be informed about this when creating a new issue as shown above.

To keep an issue private you can click on the “Contains Confidential Info” checkbox when creating or modifying an issue. This will prevent other users from seeing your issue (although of course the administrators at Research In Motion® (RIM®) will still be able to see your issue and to act on it).

The default setting of the public/private permission when creating new issues is configurable in your Issue Tracker profile. You can modify it by clicking on the link shown when creating a new issue (screenshot above) or by modifying the setting in your user profile. Here is how you can switch back to the previous configuration where issues you log are kept private by changing the setting in your profile:

1. Log into Issue Tracker.

2. Click on the arrow beside your username and choose Profile.

3. Click on the “Configure Reporter Issue Preferences” link on the bottom left corner of the page.

4. Change “Public Visibility by Default” to “No” and click on “Update”.

New issues you create will now be set to private by default.

Please let us know if you have any questions by leaving a comment below!

Given that, a common question I’m asked by ExtraView administrators who are looking to roll out their second ExtraView system is whether they should put that new system in a new ExtraView instance or create it within the existing instance.  An ExtraView instance that contains multiple systems is sometimes referred to as a multi-tenant instance.   There are pros and cons to multi-tenant instances. The pros are: consolidated reporting, shared licenses, and one database to maintain.  The cons include:  additional coordination, additional complexity, and little or no improvement in hardware utilization.

Pros of a Multi-tenant Instance

Consolidated Reporting - ExtraView has robust native reporting capabilities. Any user can easily create and share any number of reports and dashboards in a variety of formats and filters.  When multiple groups reside in the same ExtraView instance you can create reports that consolidate data across all groups within that instance.  Hence, in one site you can have a consolidated dashboard that allows management to view metrics and trends for all groups within the ExtraView instance. If those groups were in separate ExtraView instances, management would have to log into each site in order to see the same data, and the trends would not always be obvious.  (Note that the ability to render consolidated reports does not mean all users will automatically see all data within the ExtraView instance. You can use a variety of security and privacy settings to hide as much of your data as desired.)

Shared Licenses – ExtraView supports named and concurrent user licenses. Named user licenses are assigned to individual users. Concurrent licenses can be shared across multiple users within the same ExtraView instance. When a user who is assigned to concurrent licenses logs into the system, they “check out” one of the available concurrent licenses from the “bank” of available concurrent licenses. If all the concurrent licenses have been checked out, then that user cannot log in.

Concurrent licenses cost 4.2 times more than named user licenses. Hence, in general it is most cost-effective to assign named user licenses only to users who will spend most of their day working in ExtraView and assign concurrent user licenses to everyone else.   

Given that, there is a financial benefit to putting multiple groups into the same ExtraView instance because a larger group of users can more effectively share a pool of concurrent licenses. This is particularly true when users are dispersed across distant time zones. Similarly, there’s a financial benefit to a multi-tenant ExtraView instance if particular users need access to the same systems within that instance. This benefit is magnified when the user requires a named user license.

That said, there are various times when there’s negligible potential financial benefit to sharing licenses within a single instance. For example, there’s no benefit if most of your users require named user licenses and do not need access to both systems. Likewise, the financial benefit is diminished if most of your concurrent users are located within the same time zone and/or will simultaneously access the system.  In addition, sharing licenses across multiple groups can present administrative challenges.  Oftentimes these administrative challenges outweigh the potential benefit of sharing licenses.  For example, as the group sharing the licenses gets larger, it requires more effort to identify which group is actually using the licenses more.  This is often problematic because licenses are funded from different group budgets.

Database Maintenance – There are various typical tasks associated with setting up and maintaining an ExtraView instance. Set-up generally includes installing the software (i.e. ExtraView, application server, web server, and database software); configuring that software; establishing URLs; configuring LDAP/AD; importing your schema; setting up monitoring and back-ups; etc. Maintenance tasks generally include making sure your monitoring and back-ups continue to work properly. Most of these tasks are not very time-consuming; however, there is marginal benefit to doing them once for one ExtraView instance instead of multiple times for separate instances.

That said, most set-up tasks need only be done once, even if you maintain multiple separate ExtraView instances. For example, you need only install once the database software, the application server and the web server software. (Note:  ExtraView is designed to allow you to run multiple instances within one application server, and run multiple application servers on same server hardware.)

Likewise, once you configure backups, monitoring, and LDAP/AD for your first ExtraView instance, it’s very easy to set these up for subsequent ExtraView instances. In our experience, which includes managing thousands of hosted ExtraView instances since 1999, there’s little measurable incremental effort to maintaining multiple ExtraView instances vs. a multi-tenant instance(s).

Cons of a Multi-tenant Instance

Coordination Required - If two or more groups reside within the same ExtraView instance, they will need to coordinate various tasks, such as upgrades and significant new development. Upgrades and significant new development involve some risk that existing functionality can “break”, and thus we recommend you thoroughly test your ExtraView system when performing these events.  Sometimes it can be very difficult to coordinate these events, such as when each group is on different product release schedules or calendar events. A group in the latter stages of a product release or in the middle of their quarter end close is not likely to want to undergo an upgrade.

You will likewise need to coordinate on the set up of certain global objects in a multi-tenant ExtraView instance. For example, you will need to coordinate the list values that appear in key global list fields, such as Status or Product. If you don’t coordinate these, you will likely end up with redundant list values (e.g. multiple Status fields that mean the same thing, such as “New” and “Submitted”) or numerous redundant list fields (e.g. two or three fields called “Product”). Once that happens you lose much of the benefit of consolidated reporting described above.

Additional Complexity - A multi-tenant ExtraView instance can be more complex to set up and maintain. The primary reason for this is that when setting up your site you will continually have the opportunity to configure functionality at either a global or group level. That additional choice provides complexity. For example, does it make sense to create two separate roles, such as “Engineer” and “Developer”, or is it better to have one role and use other configuration techniques to control what that role can do in each Area and Project? You likely wouldn’t need to make that configuration decision where each group maintains their own ExtraView instance.  Likewise, if in the future you wish to modify the security settings associated with each Role, it is more complicated in a multi-tenant ExtraView instance.

Although ExtraView’s architecture provides comprehensive security, setting up and maintaining that security is the result of turning off and on many behavior settings, security permissions, and other configurations.  This can become more complicated with each group you add to the instance.  Furthermore, eventually you increase the risks that human error could result in a change that unintentionally exposes one group’s data to another group. Hence, maintaining separate instances is generally more secure.

Finally, other tasks can also become more complicated in a multi-tenant instance.  For example, you will inevitably need to tear down and archive group systems that are no longer used.  That is much easier to accomplish when the data is maintained in a separate instance.  You will also need to periodically migrate some systems. For example, many of our customers start off hosted on our servers but eventually migrate to their own in-house servers.  That migration is much easier because we maintain their data in separate instances.

No Increase in Hardware Utilization – A common argument for multi-tenancy is that you gain cost savings through better utilization of the hardware. However, for the past twelve years we have hosted many thousands of customer sites and have seen little difference in hardware utilization between hosting multi-tenant vs. separate instances. In fact to the contrary, we have found that a multi-tenant instance is generally more complicated and requires more powerful hardware.  More specifically, in a shared instance you need to size hardware to accommodate the most complex processes/groups.  This can often be more expensive than just breaking those processes/groups out into separate instances.  For example, we find that we can generally put up about seven Tomcat application servers on a modest server, and each Tomcat can hold about 15 ExtraView instances. Hence, one modest application server can host up to 105 unique ExtraView instances. When those customer sites are much more complicated, we find that performance improves if we separate them from the other ExtraView instances and even allocate them multiple Tomcats.

Ultimately, you will need to weigh the pros and cons of a multi-tenancy vs. separate multiple ExtraView instances strategy.  Fortunately, the ExtraView architecture supports a broad variety of deployment strategies.

I welcome your comments here.

In the past, I have used Redmine. It’s easy to setup, the interface is good and it’s open source so you can add any new features you want, assuming you’re handy in Ruby on Rails.

Found a good post comparing the two.

1. 미리 준비해야 하는 것들

• 현재 Redmine은 1.2.0이며 여기에서 받을 수 있다.
• Redmine에는 Ruby(루비)가 필요한데 1.9 버전은 지원하지 않으므로 1.8.x 버전을 Ruby 공식 사이트 또는 RubyInstaller에서 받는다.
• MySQL은 5.0 이상을 권장하며 여기에서 받는다.
• Gantt를 png 파일로 내보내려면 RMagic이 필요하다. 여기에서 win32용 바이너리를 받는다. 한글 처리에 문제가 있다.

2. 설치

먼저 Ruby를 설치한다. 설치 과정 중에도 안내가 나오지만 설치 경로에 빈 칸이 없도록 주의한다. 설치 과정을 따라 그대로 진행하면 별 문제 없다.

Redmine 공식 배포판에는 필요한 Rails(레일스)와 Rack이 있으므로 따로 설치하지 않아도 되지만 소스를 받는다면 명령행에서 다음을 입력해 설치한다. 참고로 gem은 관련 라이브러리를 쉽게 설치, 삭제할 수 있는 패키지 매니저이다.

gem install rails -v=2.3.11 --include-dependencies

gem은 기본으로 설치되어 있지만 만약 설치해야 한다면 다음을 명령 행에서 입력한다^[1].

gem update -system

다음 명령을 실행하고 rake 0.8,7, i18n 0.4.2, rack 1.0.1이 있는지 확인한다. Redmine 1.2.0에서는 rack 1.1.1이 필요하다고 되어 있으나 실제 포함된 rails 패키지가 2.3.5이므로 rack 1.0.1을 사용해야 한다.

gem list --local

없거나 버전이 맞지 않으면 다음처럼 설치한다.

gem install rake -v=0.8.7
gem install i18n -v=0.4.2
gem install rack -v=1.0.1

Redmine은 설치할 곳에 압축을 풀어 준다. 여기서는 C:\redmine에 압축을 풀어 설치했다.

정보를 저장할 DB인 MySQL을 설치한다. 설정 과정에서 인코딩은 UTF-8로 지정한다. 그리고 Ruby에서 MySQL에 접속할 때 성능을 높일 수 있도록 C 바인딩을 설치한다.

gem install mysql

다음 내용으로 빈 DB를 만든다.

mysql -u root -p
mysql> create database redmine character set utf8;
mysql> create user 'redmine'@'localhost' identified by 'my_password';
mysql> grant all privileges on redmine.* to 'redmine'@'localhost';

만약 MySQL이 5.0.2 이전이면 create user 과정 대신 다음을 한다.

mysql> grant all privileges on redmine.* to 'redmine'@'localhost' identified by 'my_password';

이제 Redmine에 DB 접속 정보를 설정한다.

C:\redmine\config\database.yml.example 파일을 복사해 C:\redmine\config\database.yml 파일을 만들고 다음과 같이 수정한다.

production:
  adapter: mysql
  database: redmine
  host: localhost
  username: redmine
  password: my_password
  port: 3306
  encoding: utf8

포트 정보는 MySQL 기본값인 3306을 사용하지 않을 때만 지정해도 된다.

Session store secret을  만든다. Redmine을 설치한 최상위 위치(여기서는 C:\redmine)에서 한다.

rake generate_session_store (or rake config/initializers/session_store.rb)

실행 후 C:\redmine\config\initializers\session_store.rb 파일이 만들어 진 것을 확인한다.

DB 구조를 만든다. Redmine을 설치한 최상위 위치에서 다음을 실행한다. libmySQL.dll 파일을 참조할 수 없으면 DB 마이그레이션 과정에서 에러가 발생하니 Ruby187\bin에 넣어준다.

set RAILS_ENV=production
rake db:migrate

만약 다음과 같은 에러가 생기면,

gem 버전이 맞지 않아 생기는 문제이므로 다음처럼 gem 버전을 1.4.2로 바꾸고 한다^[2].

gem update --system 1.4.2

또는 여기에서 직접 받아 설치한다. zip 파일을 받아 압축을 풀고 다음처럼 설치한다.

ruby setup.rb

만약 아래와 같은 에러가 발생하면,

MySQL 라이브러리가 맞지 않아 발생하는 현상이므로 여기에서 libmySQL.dll을 받은 후 앞에서 Ruby187\bin에 넣은 것과 바꿔준다.

DB 구조를 다 만들었으면 기본 설정 정보를 추가한다. 앞에서 RAILS_ENV를 환경 설정에 추가했으면 다시 하지 않아도 된다. 각 항목에서 사용하는 기본값을 추가하는데 한글로 하려면 ko를 사용한다. 기본값은 영문이다. 이 설정과 관계 없이 메뉴를 한글로 바꾸는 것은 Redmine 설정 메뉴에서 한다.

set RAILS_ENV=production
rake redmine:load_default_data

여기까지 했으면 모든 설치는 마쳤고 이제 동작하는지 확인할 차례이다. 명령 행에서 아래 내용을 실행한 후 접속해 본다. 기본으로 사용하는 포트는 3000번이므로 여기서는 http://plab.net:3000으로 접속했다. 관리자 계정은 admin / admin이다. 접속 전에 방화벽 설정도 확인한다.

ruby script/server webrick -e production

이제 실제 사용을 위해 Apache 웹 서버와 연동한다. 리눅스라면 Phusion Passenger를 사용하는 것 같은데 윈도에서는 mongrel로 clustering을 할 수 있다. 먼저 mongrel을 설치한다.

gem install mongrel mongrel_service --include-dependencies

mongrel을 gem 파일로 받아 설치한다면 gem_plugin, cgi_multipart_eof_fix도 필요하므로 먼저 설치한다.

gem install gem_plugin
gem install cgi_multipart_eof_fix

prefix를 사용하려면 mongrel 패치를 해야 한다. C:\redmine\config\initializers에 파일을 만들고 (이름은 상관 없으며 여기서는 mongrelpatch.rb로 만들었다) 다음 내용을 넣는다.

module ActionController
  class AbstractRequest < ActionController::Request
    def self.relative_url_root=(path)
      ActionController::Base.relative_url_root=(path)
    end
    def self.relative_url_root
      ActionController::Base.relative_url_root
    end
  end
end

로드 밸런싱(load balancing)을 할 수 있도록 명령 행에서 다음 내용을 실행해 서비스를 두 개 등록한다.

mongrel_rails service::install -N redmine1 -D redmine1 -p 3001 -n 1024 -c C:\redmine -e production --prefix=/redmine
mongrel_rails service::install -N redmine2 -D redmine2 -p 3002 -n 1024 -c C:\redmine -e production --prefix=/redmine
net start redmine1
net start redmine2

참고로 서비스 삭제는 mongrel_rails service::remove -N redmine1로 할 수 있다.

다시 접속 확인을 해 본다. 이번에는 포트를 3001, 3002로 지정하고 접두어를 사용했으므로 http://plab.net:3001/redmine, http://plab.net:3002/redmine으로 접속해야 한다^[3]. 확인 후 서비스 실행을 자동으로 바꾼다.

httpd.conf 파일에 다음 내용을 추가한다.

LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_http_module modules/mod_proxy_http.so
LoadModule proxy_balancer_module modules/mod_proxy_balancer.so

<IfModule proxy_balancer_module>
  ProxyPass /redmine balancer://redmine_cluster
  ProxyPassReverse /redmine balancer://redmine_cluster

  <Proxy balancer://redmine_cluster>
    BalancerMember http://127.0.0.1:3001/redmine
    BalancerMember http://127.0.0.1:3002/redmine
  </Proxy>
</IfModule>

이제 Apache 웹 서버를 다시 실행하고 http://plab.net/redmine으로 접속하면 된다.

3. 설정

인증을 이전에 설치한 OpenLDAP을 사용하도록 바꾼다.

Administration – LDAP authenticaion 메뉴에서 New authentication mode를 선택 후 다음처럼 설정한다.

Redmine에 계정은 다음과 같은 과정으로 추가한다.

• 사용자가 Redmine에 등록
• 사용자가 등록한 계정 정보대로 관리자가 OpenLDAP에서 ou=People 아래에 계정 추가
• Redmine에서 관리자가 계정을 승인하면서 인증 방법을 internal에서 LDAP으로 변경
• 이때 관리자는 기본 암호를 부여하고 사용자는 Ldap Admin 같은 프로그램을 사용해 LDAP에서 자기 계정 암호를 직접 바꾸도록 한다.

저장소 통계 화면은 구글 크롬에서는 정상으로 볼 수 있으나 IE8에서는 볼 수 없으므로 필요하면 여기에서 SVG 뷰어를 받아 설치한다. 단 한글이 제대로 안 나오는 문제가 있다.

이메일로 변경 내용을 받으려면 C:\redmine\config\email.yml.example 파일을 복사해 C:\redmine\config\email.yml 파일을 만들고 필요한 내용을 설정한다.

production:
  delivery_method: :smtp
  smtp_settings:
    address: 127.0.0.1
    port: 25
    domain: plab.net
    authentication: :login
    user_name: account
    password: password

설정 후 Redmine 서비스를 다시 실행하고 Administration – Settings 메뉴에서 Email notifications 탭을 선택해 추가 설정을 한다.

설치한 gem과 Redmine 정보를 정리하면 다음과 같다. Redmine 정보를 보려면 Redmine을 설치한 최상위 위치에서 한다.

마지막으로 프로젝트별 저장소 설정은 해당 프로젝트를 선택한 후 Settings – Repository를 선택한 후 다음과 같이 한다.

이 때 주의할 점이 있다. 파일 이름이 한글이면 Redmine에서 Mercurial 저장소 내용을 볼 때 internal error가 발생한다. Mercurial에서 파일 이름을 한글로 쓰는 것은 문제가 없지만 Redmine과 연동을 한다면 주의해야 한다.

2.3x discontinued

Important note! The 2.3x version of Openbravo ERP has been discontinued:

• We have removed all the continuous builds involving 2.3x from our build farm.
• It’s no longer possible to report bugs against this version in our issue tracker.
• The wiki documents related to 2.3x have been marked as deprecated.
• The Mercurial code repository is permanently frozen.
• The 2.3x installers have been removed from the SourceForge download area.

I would like remind you that if you’re running a Community Edition installation you should always be in the latest major release. Currently this means 2.50. Running an old major version is possible of course, but the voluntary support you get in the forums is provided on the latest major release. The professional support is offered in all the major releases: 2.3x, 2.40, 2.50 until now and 2.40, 2.50 after this 2.3x end of life.

So this means that if you’re running 2.3x you should seriously consider upgrading to 2.50 as soon as possible. If you have problems during this process you can either post your question in the forums, which is run by volunteers, or contact your closest partner to get professional support.

Continuous Integration: graphical upgrade test

We have a new job in our build farm that really makes a difference: perform an upgrade using the Module Management Console, starting from the last release Maintenance Pack and using to the latest daily Core OBX module. This test is now a prerequisite before merging changesets from pi to main.

It’s been developed using Selenium by the QA Team (thanks for that!) and we have adapted and integrated it into our continuous integration framework.

New issue tracker statuses

Soon we’ll have 2 new statuses in our issue tracker: Ready for integration and Ready for QA. They will be placed before the Resolved status. With this change we increase our compromise with the quality of the product. Because this means that we won’t consider an issue to be resolved until our Continuous Integration and QA Team have tested them. Check the rationale behind this decision or check the new workflow in the following graph:

Issue tracker and build farm integration

Every time a changeset is successfully promoted to erp/devel/main we automatically generate an Core OBX file out of it. Now we have integrated the issue tracker with our build farm so that a note is added with information regarding when this promotion happened, in what changeset and how to get the generated OBX file. See issue #11470 to see this in action.

For a complete list of the on-going stories we’ve been working on, check the Sprint 29 page of our Scrum spreadsheet.

• Continuous Integration: there is a new job that tests upgrading from the last stable MP to the latest daily OBX file. This has been done using the command line. A graphical test is in progress.
• Live builds: the main page has been refactored and it now includes detailed build information as well as the runtime Tomcat log.
• Appliance security updates: previous versions of the appliance are vulnerable to a man-in-the-middle attack during TLS session renegotiation. This vulnerability has been addressed in this update. Check the full changelog at the newly created appliance release notes.
• Documentation: check the new document explaining our stack configuration in the appliances.
• Issue Tracker: we are working on upgrading to version 1.2.0, which includes new interesting features. Many things have changed in this version so this process will take longer than a regular update. A new testing server will be announced soon.
• Download area: the SourceForge download area has been updated to include only the latest 3 releases. The older ones have been moved to the 09-openbravo-old-releases directory.

For a complete list of the on-going stories we’ve been working on, check the Sprint 28 page of our Scrum spreadsheet.

What we needed was reasonably priced (not Jira, not $25/user) just a simple wiki with google code functionality. I mean the one that costs virtually nothing if anyone had made it.

Finally have decided to deploy Trac, although it was little hard to get it going, it was well worth it. Now we have full fledged issue tracker, with iCal and rememberthemilk integration, Time-tracking, svn browsing capabilities and so much more. Check it out here : http://trac-hacks.org/wiki/0.11

So I got what I needed. Let’s get back to why there isn’t any sensible issue-tracking system on our poor planet. How much did it cost me? $20 dedicated server on VPS . If I make a template out of this, and sell it for $50 per company with resources limited to the server it is running on, and give them the option to increase it ? And increase my revenue proportionally with it ? Yes, it’d be a promising venture and just today, I’d have turned two companies into my clients.

No I’m not saying it is the most brilliant idea of all times. I am just surprised at the fact that our precious time along with such a big and very obvious demand (=opportunity) is being wasted.

It’s very easy to drown under a weight of emails with different requests, of varying priority and ability to fix. I needed a quick way of letting people input their issues into a central store, without needing to login or navigate anything that looked remotely scary. It had to replace sending an email to me.

Here comes the Twitter bit…

I put out a call for a free bug tracker on Twitter and got a number of useful suggestions (Trac, Uservoice, Getsatisfaction) but none of them quite fit what I wanted to do. I also ran a Google search and got a couple of solutions, that required a bit of sign-up and configuration. Thinking further, I realised that a Google product that I had almost never used was actually the answer.

Creating the issue tracker

Google Spreadsheets is a free online spreadsheet system that is designed for collaboration from the ground-up. Using your inevitable Google Account, you can quickly create and publish spreadsheets to either an invite-only audience or to everyone who has the link.

Within minutes, and with Dave Mee‘s advice, I’d set up a basic spreadsheet that covered off all the key things you’d want to know if you were tracking bugs. Using the ‘Share’ button, I can create a link like the one above and let anyone look at it, or even edit it, without signing-in. For the purposes of demo, you won’t be able to edit the sample tracker, but please click ‘File / Create a Copy’ for your own version.

Keeping it simple (stupid)

Unfortunately, sending users to a spreadsheet isn’t the most friendly interface to provide them with. Remember, I needed this to replace email so that means users need a simple, easy-to-understand method to put data in there, without logging in.

Well, the great thing about Google Spreadsheets is that it can act as a basic data-collection platform. This is key, because you don’t need to share the spreadsheet and all the data stored in it in order to get data into it, nor do you need users to login to yet another system.

From the spreadsheet above, the obvious ‘Form’ menu option, I was able to quickly create a simple form that automatically updated fields relevant to the end user. For example, I wanted users to tell me the problem (Issue detail…) but I would be setting the priority level and assigning it to the right people for resolution. During the creation of the form I was easily able to edit how all the fields are displayed and whether they’re required – and delete the fields that users don’t need to see.

That form can now be emailed around to anyone relevant or embedded within another webpage, say a feedback form on a beta/testing site or even on an organisation’s intranet. It’s trivial to further configure the spreadsheet options to email you whenever anyone then adds an entry to it via the form.

Love and spreadsheets are free

Total cost of this endeavour? Zero, apart from my time which was approximately 30-45 minutes, allowing for my fiddling around. Now that all requests for fixes are routed through one place, they can be managed much more easily and transparently, saving time and with users being able (if you wish) to monitor the fix status of any issue!

Found this useful? Am I missing out on a better way to capture these issues? Leave a comment below…

Redmine is an evolved an easy to use multi-project managment environment

Looking for enterprise collaborative teaming tool with activity reports?

Redmine does it, and integrates LDAP for authentication.

Looking for an integrated svn or mercurial extention more simple and powerfull than trac?

Redimine manages repository in an awesome way, for instance the following svn commit:

svn commit -m “this patch closes #245“

closes the ticket and relates the diffs to the ticket history.

Your system support team has planned to kill you at your next request?

Redmine is entireley configurable by his web interface: no system support effort is required after installation.

Installation is a “next request” and you want to live enough see redmine working?

download the cross-platform bundled installer
(provided by bitnami.org – Open Soruce. Simplified. )

Issues with subversion repository LDAP authentication?

I’m going to write an how to on this. stay tuned!

One day I was browsing the openttdcoop wiki site. Look at this page on the wiki, it aims to solve a specific problem and on the page there are also a few proposed solutions. Every solution has a player that’s currently driving the research forward, what status the research is currently in and information about where one can read more about this little project. This, ladies and gentlemen, is a ticket.

Actually, that page has three tickets. But what’s interesting here is that they have essentially turned their wiki software into a basic issue tracking software. Why would you want to do this? Maybe you’re just starting a project, installing and maintaining all this (essential!) communication software might be a bit to much at start. Using the wiki, you can have tickets without having to worry about another install.

Or maybe the projects members feel a bit daunted by the amount of organization that is, frankly, required. A wiki is something most people are familiar with, so by moving the issue tracker into the wiki (which you use anyway for documentation), there is one less system that needs to be learned.

So how do you do it? You need to add a template to your wiki:

Template:Ticket

{| width=”40%” class=”tickettable”
! Idea !! Owner !! Status !! Remarks
|-
! align=”left” |{{{1}}}
!{{{2}}}
!class=”{{{3}}}” | {{{4}}}
!{{{5}}} |}
[[Category:Templates]]

Those curly brackets indicate an argument to the template, whatever you put there will be put into the template. If you know wiki syntax for a table, you could probably figure out the usage on your own:

Usage

{{Ticket|my idea|owner|(status)|draft|remarks}}

The “my idea” column is simply a title, a short way of saying “when this ticket is completed this will have been done”. The “owner” is your name, or your username, can also be a link to your userpage.

See the parenthesis around “status”? That’s the only field where you cant type anything you want, what that word will do is colorcode the status column. I can pick a color and then a comment or the actual word for the status column. Above, I stated “draft”. To create to color shown in the image above, I would put “wip” instead of “(status)”.

Remarks is just that, other comments and stuff you cant put anywhere else in the ticket but still think needs saying.

But what’s this all about? Colorcode? Wip? Wip is a css class, there are a few added to the main.css file so that all the our status columns are colorcoded. Also, you have to pick any of the following, such as wip (to make it yellow):

Add to main.css

.tickettable, .tickettable td, .tickettable tr, .tickettable th { border: 1px solid #3e4243; border-collapse: collapse; padding: 2px; padding-left: 5px;}
.unclaimed {background-color: #CC0033;}
.claimed {background-color: #FF6633;}
.wip {background-color: #FFCC33;}
.converted {background-color: #FFFF99; color: #000;}
.checked {background-color: #339900;}
.checked2 {background-color: #66FF99; color: #000;}
.done {background-color: #F2F2F2; color: #000;}

That’s it really. I’ve modified the template openttdcoop uses. For the end result (using my version) see the image above. This was implemented in mediawiki, if you want to try it out and run into problems, feel free to ask here.

The CNN.com politics page has what’s called Election Center 2008. The Election Center attacks the senses with interactive features and election info. CNN has some of the most trusted election coverage not only because they traditionally put the big issues first, but their wide variety of stories. Election Center also has an array of different polls to get the reader involved (and, gasp, thinking!) about their own opinion.

Election center has an election timeline tracker as well as an issue tracker. Those are the kind of features we want to see! The election tracker has some cool things such as information and charts on: polling, fundraising, add spending, candidate visits, and past results. The issue tracker is a pie chart that displays the issues that are most important to the public according to the polls. There is also a page that just simply has icons for many of the important issues and one can simply click on the icon and then it will show a report on each candidates view and stance on the topic. Does Fox have these kind of features? Nope. Grade: A+

Also, I’ve started using the issue tracker on the Google Code project page to coordinate and record issues/bugs/enhancements. If you spot a bug or simply want to make a suggestion about Awesomium, please feel free to add it to the issue tracker if it doesn’t already exist.

As for the future of Awesomium, there are several things I’m currently working on and hoping to get implemented. Support for true transparent backgrounds is one that tops my list as there is significant demand for such a feature. I haven’t had much luck getting this implemented natively and so I may end up altering the Chromium source– we’ll see how my hacking attempts go.

Another big thing I’ve been hearing requests for lately is support for Flash and other plugins. There’s several problems right now getting the Flash plugin to work: it requires a window handle (we have none), it renders directly to the window, and it isn’t painted with the WebView when invoking an offscreen paint. Nevertheless, I’ve got an idea: attempt to force the Flash plugin to always initialize in windowless mode (thereby it doesn’t require a window handle) and then intercept whenever it paints offscreen to its HDC (requires modification to Chromium). I’m still a noob at the NPAPI however and so to hone my skills, I’m currently working on creating a standalone plugin execution sandbox (so I can embed plugins like Flash without a browser).

Known as libSecondLife and libSL (Library for Second Life), this code was written as a light-weight client by a team of people who were not part of Linden Labs. It was perhaps the first introduction of the Open Source initiative to the Second Life Suite of tools and services. After officially stating that they were excited about libSL at SLCC 2006, the Lindens shortly announced afterwards that they would be making the official client open-source. The Second Life library today is used primarily as an API for programmers to perform various tasks on the grid such as unit testing, group management, land management, artificial intelligence, NPCs, experimental project, and light weight viewers (SLeek, AjaxLife). An added benefit to this project is that anyone who does not want to understand the internal workings of the API to add features can submit bounties so that other programmers will implement features for them.

Second Life Client 

Linden Labs has released the source code to its Second Life client (viewer) in the past. We have already seen the benefits of this as people have been submitting patches and optimizing code through the issue tracker (JIRA). Rouge viewers have started popping up (Nicholaz Edition) that have their own tweaks including patches that were not approved through the official issue tracker.

Second Life Sim

The Lindens are currently working on releasing the source code to their simulator.  There is potential talk of allowing people to host their own simulators outside of Second Life, and allow them to connect to the main grid. This can provide new hosting opportunities on the internet. Rather than paying Linden Labs for a sim (Currently 295 US$/month), you can pay a hosting provider at their own rate. Lower rates may be possible if they can charge by processing power or bandwidth instead for places like residential sims that don’t host big events or get a lot of traffic.

OpenSim

Just like libSL, OpenSim is also being developed outside of Linden Labs. It is a combination of four services (User, Grid, Asset, Simulator) to be able to host a full grid without the need to connect to Linden Labs grid. This may be the full realized dream of Linden Labs. The benefits here are large for the end-user as well as for businesses, educators, architects, filmmakers, and even parents.

Professional entities are not happy about some of the culture available in Second Life. These are aspects such as gambling, pornography, and conduct. Another issue includes the firewall. In order to connect to the main grid, beurocratic paperwork has to be put through with both benefits and risks. Being able to fully host the Second Life platform behind a firewall gives the added benefit of developing work that has a non disclosure agreement (NDA) tied to it.

Filmmakers may also find the OpenSim platform beneficial.  Imagine a large production set on a region spread across 50 simulators without having to pay for them. Frame rates are also vast. The current framerate on my initial trials was averaging out at 150 FPS when standing still, and would only go down to 60 FPS when spinning my camera around on a sim with 18,990 prims on it. For people creating machinima in virtual worlds, the frame rate is very important. It is hard for me to constantly maintain above 24 FPS on Linden Labs main grid while making machinima.

Parents can relax with running their own OpenSim. Rather then being restricted to the TOS on Linden Labs beta, teen, and main grid, both parent and child can work together on the same grid. Even children who are under 13 can join in on the fun. Imagine taking your child who loves to play video games and teaching them how to make things in a game? There are also many parents who will not let there children on the teen grid, just because they know of the culture that they would be exposing their child to. With OpenSim, parents have control over that culture.

OpenSim is still not perfect.  In fact, many features are missing or are currently in development. As I found my self adding objects to my private sim, the speed at which objects were added was hindered over time. It took over an hour to make 18,890 prims. The only physics in-world are those that let your avatar walk across land (and it’s jagged at best). At this past Second Life Community Convention (SLCC), the developers stated that it will be some time (six months?) before it is feature complete.

Prims are saved in a MySQL database. You can also export and import them with an XML file. Combined with libSL, this gives you the ability to build a sim out on your own computer at home and then have everything render itself on the main grid once you purchase your sim. The added benefit here is privacy before going public, and the ability to wait on a sim purchase before you are done with your build. There is also the benefit of replicating sims on the fly if you are hosting an event in-world and need multiple sims that look exactly the same (Like the NBC Christmas Lighting in November 2006 across 19 sims).

Currently, there are a few grids that you can connect to with your viewer (or your sim).  You don’t need to have OpenSim installed if you only want to connect to them with your Second Life Viewer. Public grids include OSGrid and DeepGrid. There are also a few stand-alone sims that you can connect to to play around such as CannonBall, Ruth(Zion), and CyberSpacia.